





import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


_UpperCAmelCase        =				get_tests_dir('fixtures/test_sentencepiece.model')

if is_torch_available():
     from transformers.models.mbart.modeling_mbart import shift_tokens_right

_UpperCAmelCase        =				2_5_0_0_0_4
_UpperCAmelCase        =				2_5_0_0_2_0



@require_sentencepiece
@require_tokenizers
class 							_UpperCamelCase					(	lowerCAmelCase_  ,						unittest.TestCase     ):
       _UpperCamelCase				:					List[Any]         =   MBartaaTokenizer
       _UpperCamelCase				:					Optional[int]         =   MBartaaTokenizerFast
       _UpperCamelCase				:					Tuple         =   True
       _UpperCamelCase				:					Optional[Any]         =   True

       def lowercase (		self: Dict		)       -> Any:




              """simple docstring"""


              super().setUp()

              # We have a SentencePiece fixture for testing
              UpperCamelCase_          =  MBartaaTokenizer(_SCREAMING_SNAKE_CASE					,   src_lang="en_XX"					,   tgt_lang="ro_RO"					,   keep_accents=_SCREAMING_SNAKE_CASE		)
              tokenizer.save_pretrained(self.tmpdirname		)

       def lowercase (		self: str		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  "<s>"
              UpperCamelCase_          =  0

              self.assertEqual(self.get_tokenizer()._convert_token_to_id(_SCREAMING_SNAKE_CASE		)					,   _SCREAMING_SNAKE_CASE		)
              self.assertEqual(self.get_tokenizer()._convert_id_to_token(_SCREAMING_SNAKE_CASE		)					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Dict		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_          =  list(self.get_tokenizer().get_vocab().keys()		)

              self.assertEqual(vocab_keys[0]					,   "<s>"		)
              self.assertEqual(vocab_keys[1]					,   "<pad>"		)
              self.assertEqual(vocab_keys[-1]					,   "<mask>"		)
              self.assertEqual(len(_SCREAMING_SNAKE_CASE		)					,   1054		)

       def lowercase (		self: str		)       -> Any:




              """simple docstring"""


              self.assertEqual(self.get_tokenizer().vocab_size					,   1054		)

       def lowercase (		self: str		)       -> Any:




              """simple docstring"""


              UpperCamelCase_          =  MBartaaTokenizer(_SCREAMING_SNAKE_CASE					,   src_lang="en_XX"					,   tgt_lang="ro_RO"					,   keep_accents=_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_          =  tokenizer.tokenize("This is a test"		)
              self.assertListEqual(_SCREAMING_SNAKE_CASE					,   ["▁This", "▁is", "▁a", "▁t", "est"]		)

              self.assertListEqual(
                  tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE		)					,   [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]					,   )

              UpperCamelCase_          =  tokenizer.tokenize("I was born in 92000, and this is falsé."		)
              self.assertListEqual(
                  _SCREAMING_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", "é", "."]					,   )
              UpperCamelCase_          =  tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE		)
              self.assertListEqual(
                  _SCREAMING_SNAKE_CASE					,   [
                      value + tokenizer.fairseq_offset
                      for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
                  ]					,   )

              UpperCamelCase_          =  tokenizer.convert_ids_to_tokens(_SCREAMING_SNAKE_CASE		)
              self.assertListEqual(
                  _SCREAMING_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>", "."]					,   )

       @slow
       def lowercase (		self: Optional[int]		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_          =  {"input_ids": [[250004, 11062, 82772, 7, 15, 82772, 538, 51529, 237, 17198, 1290, 206, 9, 215175, 1314, 136, 17198, 1290, 206, 9, 56359, 42, 122009, 9, 16466, 16, 87344, 4537, 9, 4717, 78381, 6, 159958, 7, 15, 24480, 618, 4, 527, 22693, 5428, 4, 2777, 24480, 9874, 4, 43523, 594, 4, 803, 18392, 33189, 18, 4, 43523, 24447, 12399, 100, 24955, 83658, 9626, 144057, 15, 839, 22335, 16, 136, 24955, 83658, 83479, 15, 39102, 724, 16, 678, 645, 2789, 1328, 4589, 42, 122009, 115774, 23, 805, 1328, 46876, 7, 136, 53894, 1940, 42227, 41159, 17721, 823, 425, 4, 27512, 98722, 206, 136, 5531, 4970, 919, 17336, 5, 2], [250004, 20080, 618, 83, 82775, 47, 479, 9, 1517, 73, 53894, 333, 80581, 110117, 18811, 5256, 1295, 51, 152526, 297, 7986, 390, 124416, 538, 35431, 214, 98, 15044, 25737, 136, 7108, 43701, 23, 756, 135355, 7, 5, 2, 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], [250004, 581, 63773, 119455, 6, 147797, 88203, 7, 645, 70, 21, 3285, 10269, 5, 2, 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]], "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, 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], [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]]}  # noqa: E501
              # fmt: on

              self.tokenizer_integration_test_util(
                  expected_encoding=_SCREAMING_SNAKE_CASE					,   model_name="facebook/mbart-large-50"					,   revision="d3913889c59cd5c9e456b269c376325eabad57e2"					,   )



       def lowercase (		self: Optional[int]		)       -> Tuple:




              """simple docstring"""


              if not self.test_slow_tokenizer:
                     # as we don't have a slow version, we can't compare the outputs between slow and fast versions
                     return

              UpperCamelCase_          =  (self.rust_tokenizer_class, "hf-internal-testing/tiny-random-mbart50", {})
              for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                     with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
                            UpperCamelCase_          =  self.rust_tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE					,   **_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  self.tokenizer_class.from_pretrained(_SCREAMING_SNAKE_CASE					,   **_SCREAMING_SNAKE_CASE		)

                            UpperCamelCase_          =  tempfile.mkdtemp()

                            UpperCamelCase_          =  tokenizer_r.save_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  tokenizer_p.save_pretrained(_SCREAMING_SNAKE_CASE		)

                            # Checks it save with the same files + the tokenizer.json file for the fast one
                            self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files		)		)
                            UpperCamelCase_          =  tuple(f for f in tokenizer_r_files if "tokenizer.json" not in f		)
                            self.assertSequenceEqual(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                            # Checks everything loads correctly in the same way
                            UpperCamelCase_          =  tokenizer_r.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  tokenizer_p.from_pretrained(_SCREAMING_SNAKE_CASE		)

                            # Check special tokens are set accordingly on Rust and Python
                            for key in tokenizer_pp.special_tokens_map:
                                   self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)		)
                                   # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
                                   # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

                            shutil.rmtree(_SCREAMING_SNAKE_CASE		)

                            # Save tokenizer rust, legacy_format=True
                            UpperCamelCase_          =  tempfile.mkdtemp()

                            UpperCamelCase_          =  tokenizer_r.save_pretrained(_SCREAMING_SNAKE_CASE					,   legacy_format=_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  tokenizer_p.save_pretrained(_SCREAMING_SNAKE_CASE		)

                            # Checks it save with the same files
                            self.assertSequenceEqual(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

                            # Checks everything loads correctly in the same way
                            UpperCamelCase_          =  tokenizer_r.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  tokenizer_p.from_pretrained(_SCREAMING_SNAKE_CASE		)

                            # Check special tokens are set accordingly on Rust and Python
                            for key in tokenizer_pp.special_tokens_map:
                                   self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)		)

                            shutil.rmtree(_SCREAMING_SNAKE_CASE		)

                            # Save tokenizer rust, legacy_format=False
                            UpperCamelCase_          =  tempfile.mkdtemp()

                            UpperCamelCase_          =  tokenizer_r.save_pretrained(_SCREAMING_SNAKE_CASE					,   legacy_format=_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  tokenizer_p.save_pretrained(_SCREAMING_SNAKE_CASE		)

                            # Checks it saved the tokenizer.json file
                            self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files		)		)

                            # Checks everything loads correctly in the same way
                            UpperCamelCase_          =  tokenizer_r.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  tokenizer_p.from_pretrained(_SCREAMING_SNAKE_CASE		)

                            # Check special tokens are set accordingly on Rust and Python
                            for key in tokenizer_pp.special_tokens_map:
                                   self.assertTrue(hasattr(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)		)

                            shutil.rmtree(_SCREAMING_SNAKE_CASE		)



@require_torch
@require_sentencepiece
@require_tokenizers
class 							_UpperCamelCase					(	unittest.TestCase     ):
       _UpperCamelCase				:					Dict         =   '''facebook/mbart-large-50-one-to-many-mmt'''
       _UpperCamelCase				:					List[Any]         =   [
           ''' UN Chief Says There Is No Military Solution in Syria''',
           ''' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.''',
       ]
       _UpperCamelCase				:					List[str]         =   [
           '''Şeful ONU declară că nu există o soluţie militară în Siria''',
           '''Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'''
           ''' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor'''
           ''' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.''',
       ]
       _UpperCamelCase				:					Union[str, Any]         =   [EN_CODE, 8_2_7_4, 1_2_7_8_7_3, 2_5_9_1_6, 7, 8_6_2_2, 2_0_7_1, 4_3_8, 6_7_4_8_5, 5_3, 1_8_7_8_9_5, 2_3, 5_1_7_1_2, 2]

       @classmethod
       def lowercase (		cls: Union[str, Any]		)       -> List[str]:




              """simple docstring"""


              UpperCamelCase_          =  MBartaaTokenizer.from_pretrained(
                  cls.checkpoint_name					,   src_lang="en_XX"					,   tgt_lang="ro_RO"		)
              UpperCamelCase_          =  1
              return cls

       def lowercase (		self: List[Any]		)       -> int:




              """simple docstring"""


              self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ar_AR"]					,   250001		)
              self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["en_EN"]					,   250004		)
              self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ro_RO"]					,   250020		)
              self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["mr_IN"]					,   250038		)

       def lowercase (		self: List[Any]		)       -> str:




              """simple docstring"""


              UpperCamelCase_          =  self.tokenizer.batch_encode_plus(self.src_text		).input_ids[0]
              self.assertListEqual(self.expected_src_tokens					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: int		)       -> Tuple:




              """simple docstring"""


              self.assertIn(_SCREAMING_SNAKE_CASE					,   self.tokenizer.all_special_ids		)
              UpperCamelCase_          =  [RO_CODE, 884, 9019, 96, 9, 916, 86792, 36, 18743, 15596, 5, 2]
              UpperCamelCase_          =  self.tokenizer.decode(_SCREAMING_SNAKE_CASE					,   skip_special_tokens=_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  self.tokenizer.decode(generated_ids[1:]					,   skip_special_tokens=_SCREAMING_SNAKE_CASE		)
              self.assertEqual(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
              self.assertNotIn(self.tokenizer.eos_token					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Any		)       -> Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_          =  ["this is gunna be a long sentence " * 20]
              assert isinstance(src_text[0]					,   _SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  10
              UpperCamelCase_          =  self.tokenizer(_SCREAMING_SNAKE_CASE					,   max_length=_SCREAMING_SNAKE_CASE					,   truncation=_SCREAMING_SNAKE_CASE		).input_ids[0]
              self.assertEqual(ids[0]					,   _SCREAMING_SNAKE_CASE		)
              self.assertEqual(ids[-1]					,   2		)
              self.assertEqual(len(_SCREAMING_SNAKE_CASE		)					,   _SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Any		)       -> List[Any]:




              """simple docstring"""


              self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"]		)					,   [250053, 250001]		)

       def lowercase (		self: Optional[int]		)       -> Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_          =  tempfile.mkdtemp()
              UpperCamelCase_          =  self.tokenizer.fairseq_tokens_to_ids
              self.tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  MBartaaTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
              self.assertDictEqual(new_tok.fairseq_tokens_to_ids					,   _SCREAMING_SNAKE_CASE		)

       @require_torch
       def lowercase (		self: Dict		)       -> str:




              """simple docstring"""


              UpperCamelCase_          =  self.tokenizer(self.src_text					,   text_target=self.tgt_text					,   padding=_SCREAMING_SNAKE_CASE					,   return_tensors="pt"		)
              UpperCamelCase_          =  shift_tokens_right(batch["labels"]					,   self.tokenizer.pad_token_id		)

              # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
              assert batch.input_ids[1][0] == EN_CODE
              assert batch.input_ids[1][-1] == 2
              assert batch.labels[1][0] == RO_CODE
              assert batch.labels[1][-1] == 2
              assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]

       @require_torch
       def lowercase (		self: Any		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  self.tokenizer(
                  self.src_text					,   text_target=self.tgt_text					,   padding=_SCREAMING_SNAKE_CASE					,   truncation=_SCREAMING_SNAKE_CASE					,   max_length=len(self.expected_src_tokens		)					,   return_tensors="pt"					,   )
              UpperCamelCase_          =  shift_tokens_right(batch["labels"]					,   self.tokenizer.pad_token_id		)

              self.assertIsInstance(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

              self.assertEqual((2, 14)					,   batch.input_ids.shape		)
              self.assertEqual((2, 14)					,   batch.attention_mask.shape		)
              UpperCamelCase_          =  batch.input_ids.tolist()[0]
              self.assertListEqual(self.expected_src_tokens					,   _SCREAMING_SNAKE_CASE		)
              self.assertEqual(2					,   batch.decoder_input_ids[0, 0]		)  # decoder_start_token_id
              # Test that special tokens are reset
              self.assertEqual(self.tokenizer.prefix_tokens					,   [EN_CODE]		)
              self.assertEqual(self.tokenizer.suffix_tokens					,   [self.tokenizer.eos_token_id]		)

       def lowercase (		self: List[str]		)       -> str:




              """simple docstring"""


              UpperCamelCase_          =  self.tokenizer(self.src_text					,   padding=_SCREAMING_SNAKE_CASE					,   truncation=_SCREAMING_SNAKE_CASE					,   max_length=3					,   return_tensors="pt"		)
              UpperCamelCase_          =  self.tokenizer(
                  text_target=self.tgt_text					,   padding=_SCREAMING_SNAKE_CASE					,   truncation=_SCREAMING_SNAKE_CASE					,   max_length=10					,   return_tensors="pt"		)
              UpperCamelCase_          =  targets["input_ids"]
              UpperCamelCase_          =  shift_tokens_right(_SCREAMING_SNAKE_CASE					,   self.tokenizer.pad_token_id		)

              self.assertEqual(batch.input_ids.shape[1]					,   3		)
              self.assertEqual(batch.decoder_input_ids.shape[1]					,   10		)



       @require_torch
       def lowercase (		self: Optional[Any]		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  self.tokenizer._build_translation_inputs(
                  "A test"					,   return_tensors="pt"					,   src_lang="en_XX"					,   tgt_lang="ar_AR"		)

              self.assertEqual(
                  nested_simplify(_SCREAMING_SNAKE_CASE		)					,   {
                      # en_XX, A, test, EOS
                      "input_ids": [[250004, 62, 3034, 2]],
                      "attention_mask": [[1, 1, 1, 1]],
                      # ar_AR
                      "forced_bos_token_id": 250001,
                  }					,   )








import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
     import torch

     from transformers import (
         FalconForCausalLM,
         FalconForQuestionAnswering,
         FalconForSequenceClassification,
         FalconForTokenClassification,
         FalconModel,
     )



class 							_UpperCamelCase					:

       def __init__(		self: Dict					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any]=3					,   _SCREAMING_SNAKE_CASE: Any=7					,   _SCREAMING_SNAKE_CASE: Union[str, Any]=True					,   _SCREAMING_SNAKE_CASE: Optional[int]=True					,   _SCREAMING_SNAKE_CASE: List[Any]=False					,   _SCREAMING_SNAKE_CASE: str=True					,   _SCREAMING_SNAKE_CASE: Any=99					,   _SCREAMING_SNAKE_CASE: List[str]=32					,   _SCREAMING_SNAKE_CASE: List[str]=5					,   _SCREAMING_SNAKE_CASE: Optional[int]=4					,   _SCREAMING_SNAKE_CASE: str=37					,   _SCREAMING_SNAKE_CASE: Optional[int]="gelu"					,   _SCREAMING_SNAKE_CASE: str=0.1					,   _SCREAMING_SNAKE_CASE: Any=0.1					,   _SCREAMING_SNAKE_CASE: Optional[Any]=512					,   _SCREAMING_SNAKE_CASE: Optional[Any]=16					,   _SCREAMING_SNAKE_CASE: Union[str, Any]=2					,   _SCREAMING_SNAKE_CASE: Tuple=0.02					,   _SCREAMING_SNAKE_CASE: Optional[Any]=3					,   _SCREAMING_SNAKE_CASE: Union[str, Any]=4					,   _SCREAMING_SNAKE_CASE: Tuple=None					,   )       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  parent
              UpperCamelCase_          =  batch_size
              UpperCamelCase_          =  seq_length
              UpperCamelCase_          =  is_training
              UpperCamelCase_          =  use_input_mask
              UpperCamelCase_          =  use_token_type_ids
              UpperCamelCase_          =  use_labels
              UpperCamelCase_          =  vocab_size
              UpperCamelCase_          =  hidden_size
              UpperCamelCase_          =  num_hidden_layers
              UpperCamelCase_          =  num_attention_heads
              UpperCamelCase_          =  intermediate_size
              UpperCamelCase_          =  hidden_act
              UpperCamelCase_          =  hidden_dropout_prob
              UpperCamelCase_          =  attention_probs_dropout_prob
              UpperCamelCase_          =  max_position_embeddings
              UpperCamelCase_          =  type_vocab_size
              UpperCamelCase_          =  type_sequence_label_size
              UpperCamelCase_          =  initializer_range
              UpperCamelCase_          =  num_labels
              UpperCamelCase_          =  num_choices
              UpperCamelCase_          =  scope

       def lowercase (		self: Any		)       -> Any:




              """simple docstring"""


              UpperCamelCase_          =  ids_tensor([self.batch_size, self.seq_length]					,   self.vocab_size		)

              UpperCamelCase_          =  None
              if self.use_input_mask:
                     UpperCamelCase_          =  random_attention_mask([self.batch_size, self.seq_length]		)

              UpperCamelCase_          =  None

              UpperCamelCase_          =  None
              UpperCamelCase_          =  None
              UpperCamelCase_          =  None
              if self.use_labels:
                     UpperCamelCase_          =  ids_tensor([self.batch_size]					,   self.type_sequence_label_size		)
                     UpperCamelCase_          =  ids_tensor([self.batch_size, self.seq_length]					,   self.num_labels		)
                     UpperCamelCase_          =  ids_tensor([self.batch_size]					,   self.num_choices		)

              UpperCamelCase_          =  self.get_config()

              return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

       def lowercase (		self: Any		)       -> Union[str, Any]:




              """simple docstring"""


              return FalconConfig(
                  vocab_size=self.vocab_size					,   hidden_size=self.hidden_size					,   num_hidden_layers=self.num_hidden_layers					,   num_attention_heads=self.num_attention_heads					,   intermediate_size=self.intermediate_size					,   hidden_act=self.hidden_act					,   hidden_dropout_prob=self.hidden_dropout_prob					,   attention_probs_dropout_prob=self.attention_probs_dropout_prob					,   max_position_embeddings=self.max_position_embeddings					,   type_vocab_size=self.type_vocab_size					,   is_decoder=_SCREAMING_SNAKE_CASE					,   initializer_range=self.initializer_range					,   pad_token_id=1					,   new_decoder_architecture=_SCREAMING_SNAKE_CASE					,   )

       def lowercase (		self: str					,   _SCREAMING_SNAKE_CASE: Any					,   _SCREAMING_SNAKE_CASE: List[str]					,   _SCREAMING_SNAKE_CASE: Dict					,   _SCREAMING_SNAKE_CASE: List[str]					,   _SCREAMING_SNAKE_CASE: int					,   _SCREAMING_SNAKE_CASE: Dict					,   _SCREAMING_SNAKE_CASE: Union[str, Any]		)       -> Optional[int]:




              """simple docstring"""


              UpperCamelCase_          =  FalconModel(config=_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()
              UpperCamelCase_          =  model(_SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  model(_SCREAMING_SNAKE_CASE		)
              self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size)		)

       def lowercase (		self: Optional[int]					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: Union[str, Any]					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: Tuple					,   _SCREAMING_SNAKE_CASE: List[str]					,   _SCREAMING_SNAKE_CASE: Any					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: str					,   _SCREAMING_SNAKE_CASE: Tuple					,   )       -> str:




              """simple docstring"""


              UpperCamelCase_          =  True
              UpperCamelCase_          =  FalconModel(_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()
              UpperCamelCase_          =  model(
                  _SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE					,   encoder_hidden_states=_SCREAMING_SNAKE_CASE					,   encoder_attention_mask=_SCREAMING_SNAKE_CASE					,   )
              UpperCamelCase_          =  model(
                  _SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE					,   encoder_hidden_states=_SCREAMING_SNAKE_CASE					,   )
              UpperCamelCase_          =  model(_SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE		)
              self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size)		)

       def lowercase (		self: Optional[int]					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Union[str, Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Union[str, Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Any					,   _SCREAMING_SNAKE_CASE: int					,   )       -> int:




              """simple docstring"""


              UpperCamelCase_          =  FalconForCausalLM(config=_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()
              UpperCamelCase_          =  model(_SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE					,   labels=_SCREAMING_SNAKE_CASE		)
              self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.seq_length, self.vocab_size)		)

       def lowercase (		self: Optional[int]					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: int					,   _SCREAMING_SNAKE_CASE: Any					,   _SCREAMING_SNAKE_CASE: Union[str, Any]					,   _SCREAMING_SNAKE_CASE: Optional[int]					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any]					,   _SCREAMING_SNAKE_CASE: Tuple					,   _SCREAMING_SNAKE_CASE: Union[str, Any]					,   )       -> List[Any]:




              """simple docstring"""


              UpperCamelCase_          =  True
              UpperCamelCase_          =  True
              UpperCamelCase_          =  FalconForCausalLM(config=_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()

              # first forward pass
              UpperCamelCase_          =  model(
                  _SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE					,   encoder_hidden_states=_SCREAMING_SNAKE_CASE					,   encoder_attention_mask=_SCREAMING_SNAKE_CASE					,   use_cache=_SCREAMING_SNAKE_CASE					,   )
              UpperCamelCase_          =  outputs.past_key_values

              # create hypothetical multiple next token and extent to next_input_ids
              UpperCamelCase_          =  ids_tensor((self.batch_size, 3)					,   config.vocab_size		)
              UpperCamelCase_          =  ids_tensor((self.batch_size, 3)					,   vocab_size=2		)

              # append to next input_ids and
              UpperCamelCase_          =  torch.cat([input_ids, next_tokens]					,   dim=-1		)
              UpperCamelCase_          =  torch.cat([input_mask, next_mask]					,   dim=-1		)

              UpperCamelCase_          =  model(
                  _SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE					,   encoder_hidden_states=_SCREAMING_SNAKE_CASE					,   encoder_attention_mask=_SCREAMING_SNAKE_CASE					,   output_hidden_states=_SCREAMING_SNAKE_CASE					,   )["hidden_states"][0]
              UpperCamelCase_          =  model(
                  _SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE					,   encoder_hidden_states=_SCREAMING_SNAKE_CASE					,   encoder_attention_mask=_SCREAMING_SNAKE_CASE					,   past_key_values=_SCREAMING_SNAKE_CASE					,   output_hidden_states=_SCREAMING_SNAKE_CASE					,   )["hidden_states"][0]

              # select random slice
              UpperCamelCase_          =  ids_tensor((1,)					,   output_from_past.shape[-1]		).item()
              UpperCamelCase_          =  output_from_no_past[:, -3:, random_slice_idx].detach()
              UpperCamelCase_          =  output_from_past[:, :, random_slice_idx].detach()

              self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]		)

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



       def lowercase (		self: Tuple		)       -> int:




              """simple docstring"""


              UpperCamelCase_          =  self.prepare_config_and_inputs()
              (
                  (
                  UpperCamelCase_
              )       , (
                  UpperCamelCase_
              )       , (
                  UpperCamelCase_
              )       , (
                  UpperCamelCase_
              )       , (
                  UpperCamelCase_
              )       , (
                  UpperCamelCase_
              )       , (
                  UpperCamelCase_
              )       , 
              )          =  config_and_inputs
              UpperCamelCase_          =  {"input_ids": input_ids, "attention_mask": input_mask}
              return config, inputs_dict



@require_torch
class 							_UpperCamelCase					(	lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						unittest.TestCase     ):
       _UpperCamelCase				:					Optional[Any]         =   (
           (
               FalconModel,
               FalconForCausalLM,
               FalconForSequenceClassification,
               FalconForTokenClassification,
               FalconForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       _UpperCamelCase				:					Union[str, Any]         =   (FalconForCausalLM,) if is_torch_available() else ()
       _UpperCamelCase				:					Optional[int]         =   (
           {
               '''feature-extraction''': FalconModel,
               '''text-classification''': FalconForSequenceClassification,
               '''text-generation''': FalconForCausalLM,
               '''question-answering''': FalconForQuestionAnswering,
               '''token-classification''': FalconForTokenClassification,
               '''zero-shot''': FalconForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       _UpperCamelCase				:					Any         =   False
       _UpperCamelCase				:					int         =   False

       def lowercase (		self: str		)       -> Optional[int]:




              """simple docstring"""


              UpperCamelCase_          =  FalconModelTester(self		)
              UpperCamelCase_          =  ConfigTester(self					,   config_class=_SCREAMING_SNAKE_CASE					,   hidden_size=37		)

       def lowercase (		self: Optional[Any]		)       -> Optional[int]:




              """simple docstring"""


              self.config_tester.run_common_tests()

       def lowercase (		self: str		)       -> Any:




              """simple docstring"""


              UpperCamelCase_          =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE		)

       def lowercase (		self: List[Any]		)       -> Dict:




              """simple docstring"""


              UpperCamelCase_       , *UpperCamelCase_          =  self.model_tester.prepare_config_and_inputs()
              for alibi in [True, False]:
                     UpperCamelCase_          =  alibi
                     self.model_tester.create_and_check_model(_SCREAMING_SNAKE_CASE					,   *_SCREAMING_SNAKE_CASE		)

       def lowercase (		self: Any		)       -> str:




              """simple docstring"""


              UpperCamelCase_       , UpperCamelCase_          =  self.model_tester.prepare_config_and_inputs_for_common()
              UpperCamelCase_          =  3
              UpperCamelCase_          =  input_dict["input_ids"]
              UpperCamelCase_          =  input_ids.ne(1		).to(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  ids_tensor([self.model_tester.batch_size]					,   self.model_tester.type_sequence_label_size		)
              UpperCamelCase_          =  FalconForSequenceClassification(_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()
              UpperCamelCase_          =  model(_SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE					,   labels=_SCREAMING_SNAKE_CASE		)
              self.assertEqual(result.logits.shape					,   (self.model_tester.batch_size, self.model_tester.num_labels)		)

       def lowercase (		self: Dict		)       -> List[str]:




              """simple docstring"""


              UpperCamelCase_       , UpperCamelCase_          =  self.model_tester.prepare_config_and_inputs_for_common()
              UpperCamelCase_          =  3
              UpperCamelCase_          =  "single_label_classification"
              UpperCamelCase_          =  input_dict["input_ids"]
              UpperCamelCase_          =  input_ids.ne(1		).to(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  ids_tensor([self.model_tester.batch_size]					,   self.model_tester.type_sequence_label_size		)
              UpperCamelCase_          =  FalconForSequenceClassification(_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()
              UpperCamelCase_          =  model(_SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE					,   labels=_SCREAMING_SNAKE_CASE		)
              self.assertEqual(result.logits.shape					,   (self.model_tester.batch_size, self.model_tester.num_labels)		)

       def lowercase (		self: List[str]		)       -> int:




              """simple docstring"""


              UpperCamelCase_       , UpperCamelCase_          =  self.model_tester.prepare_config_and_inputs_for_common()
              UpperCamelCase_          =  input_dict["input_ids"]
              UpperCamelCase_          =  FalconForCausalLM(_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()
              UpperCamelCase_          =  model(_SCREAMING_SNAKE_CASE					,   use_cache=_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  input_ids.shape[0]
              UpperCamelCase_          =  model._convert_to_rw_cache(result.past_key_values		)
              UpperCamelCase_          =  model._convert_cache_to_standard_format(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)
              for layer in range(len(_SCREAMING_SNAKE_CASE		)		):
                     for tensor_idx in range(2		):
                            self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3		)
                            self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4		)
                            self.assertTrue(
                                torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]		)		)

       def lowercase (		self: Union[str, Any]		)       -> Any:




              """simple docstring"""


              UpperCamelCase_       , UpperCamelCase_          =  self.model_tester.prepare_config_and_inputs_for_common()
              UpperCamelCase_          =  3
              UpperCamelCase_          =  "multi_label_classification"
              UpperCamelCase_          =  input_dict["input_ids"]
              UpperCamelCase_          =  input_ids.ne(1		).to(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  ids_tensor(
                  [self.model_tester.batch_size, config.num_labels]					,   self.model_tester.type_sequence_label_size		).to(torch.float		)
              UpperCamelCase_          =  FalconForSequenceClassification(_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()
              UpperCamelCase_          =  model(_SCREAMING_SNAKE_CASE					,   attention_mask=_SCREAMING_SNAKE_CASE					,   labels=_SCREAMING_SNAKE_CASE		)
              self.assertEqual(result.logits.shape					,   (self.model_tester.batch_size, self.model_tester.num_labels)		)



       def lowercase (		self: List[Any]		)       -> List[Any]:




              """simple docstring"""


              for model_class in self.all_generative_model_classes:
                     UpperCamelCase_       , UpperCamelCase_          =  self.model_tester.prepare_config_and_inputs_for_common()

                     # If it doesn't support cache, pass the test
                     if not hasattr(_SCREAMING_SNAKE_CASE					,   "use_cache"		):
                            return

                     UpperCamelCase_          =  model_class(_SCREAMING_SNAKE_CASE		).to(_SCREAMING_SNAKE_CASE		)
                     if "use_cache" not in inputs:
                            UpperCamelCase_          =  True
                     UpperCamelCase_          =  model(**_SCREAMING_SNAKE_CASE		)

                     # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
                     if "past_key_values" not in outputs:
                            return

                     UpperCamelCase_          =  (
                         getattr(_SCREAMING_SNAKE_CASE					,   "decoder_layers"					,   _SCREAMING_SNAKE_CASE		)
                         or getattr(_SCREAMING_SNAKE_CASE					,   "num_decoder_layers"					,   _SCREAMING_SNAKE_CASE		)
                         or config.num_hidden_layers
                     )
                     UpperCamelCase_          =  getattr(_SCREAMING_SNAKE_CASE					,   "num_kv_heads"					,   config.num_attention_heads		)
                     UpperCamelCase_          =  getattr(_SCREAMING_SNAKE_CASE					,   "d_model"					,   config.hidden_size		)
                     UpperCamelCase_          =  embed_dim // num_attention_heads

                     UpperCamelCase_          =  outputs["past_key_values"]
                     self.assertEqual(len(_SCREAMING_SNAKE_CASE		)					,   _SCREAMING_SNAKE_CASE		)

                     UpperCamelCase_       , UpperCamelCase_          =  inputs["input_ids"].shape
                     for i in range(_SCREAMING_SNAKE_CASE		):
                            if config.new_decoder_architecture:
                                   UpperCamelCase_          =  config.num_attention_heads
                            elif config.multi_query:
                                   UpperCamelCase_          =  1
                            self.assertEqual(len(past_kv[0]		)					,   2		)  # K V for the decoder = 2
                            self.assertEqual(
                                past_kv[i][0].shape					,   (batch_size, num_attention_heads, seq_length, per_head_embed_dim)		)
                            self.assertEqual(
                                past_kv[i][1].shape					,   (batch_size, num_attention_heads, seq_length, per_head_embed_dim)		)



@require_torch
class 							_UpperCamelCase					(	unittest.TestCase     ):

       @slow
       def lowercase (		self: Tuple		)       -> int:




              """simple docstring"""


              UpperCamelCase_          =  AutoTokenizer.from_pretrained("Rocketknight1/falcon-rw-1b"		)
              UpperCamelCase_          =  FalconForCausalLM.from_pretrained("Rocketknight1/falcon-rw-1b"		)
              model.eval()
              model.to(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_          =  tokenizer("My favorite food is"					,   return_tensors="pt"		).to(_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_          =  (
                  "My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday."
              )

              UpperCamelCase_          =  model.generate(**_SCREAMING_SNAKE_CASE					,   do_sample=_SCREAMING_SNAKE_CASE					,   max_new_tokens=19		)
              UpperCamelCase_          =  tokenizer.batch_decode(_SCREAMING_SNAKE_CASE		)[0]

              self.assertEqual(_SCREAMING_SNAKE_CASE					,   _SCREAMING_SNAKE_CASE		)

       @slow
       def lowercase (		self: Dict		)       -> Dict:




              """simple docstring"""


              for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
                     UpperCamelCase_          =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
                     UpperCamelCase_          =  FalconForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE		)
                     model.eval()
                     model.to(_SCREAMING_SNAKE_CASE		)
                     UpperCamelCase_          =  tokenizer("My favorite food is"					,   return_tensors="pt"		).to(_SCREAMING_SNAKE_CASE		)

                     # We just test that these run without errors - the models are randomly initialized
                     # and so the actual text outputs will be garbage
                     model.generate(**_SCREAMING_SNAKE_CASE					,   do_sample=_SCREAMING_SNAKE_CASE					,   max_new_tokens=4		)
                     model.generate(**_SCREAMING_SNAKE_CASE					,   do_sample=_SCREAMING_SNAKE_CASE					,   max_new_tokens=4		)
                     model.generate(**_SCREAMING_SNAKE_CASE					,   num_beams=2					,   max_new_tokens=4		)



       @slow
       def lowercase (		self: Union[str, Any]		)       -> Any:




              """simple docstring"""


              with torch.no_grad():
                     for repo in [
                         "Rocketknight1/falcon-rw-1b",
                         "Rocketknight1/tiny-random-falcon-7b",
                         "Rocketknight1/tiny-random-falcon-40b",
                     ]:
                            UpperCamelCase_          =  AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  FalconForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE		)
                            model.eval()
                            model.to(device=_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  tokenizer("My favorite food is"					,   return_tensors="pt"		).to(_SCREAMING_SNAKE_CASE		)

                            # Test results are the same with and without cache
                            UpperCamelCase_          =  model.generate(**_SCREAMING_SNAKE_CASE					,   do_sample=_SCREAMING_SNAKE_CASE					,   max_new_tokens=20					,   use_cache=_SCREAMING_SNAKE_CASE		)
                            UpperCamelCase_          =  model.generate(**_SCREAMING_SNAKE_CASE					,   do_sample=_SCREAMING_SNAKE_CASE					,   max_new_tokens=20					,   use_cache=_SCREAMING_SNAKE_CASE		)
                            self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0		)

