'''simple docstring'''

import inspect
import unittest

import numpy as np

from transformers import BeitConfig
from transformers.testing_utils import require_flax, require_vision, slow
from transformers.utils import cached_property, is_flax_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor


if is_flax_available():
       import jax

       from transformers import FlaxBeitForImageClassification, FlaxBeitForMaskedImageModeling, FlaxBeitModel

if is_vision_available():
       from PIL import Image

       from transformers import BeitImageProcessor





class 							lowercase						(						unittest.TestCase ):


   def __init__(   self				:	Optional[int]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Any=100   ,		__lowerCAmelCase				:	Tuple=13   ,		__lowerCAmelCase				:	Any=30   ,		__lowerCAmelCase				:	Any=2   ,		__lowerCAmelCase				:	Union[str, Any]=3   ,		__lowerCAmelCase				:	Dict=True   ,		__lowerCAmelCase				:	List[Any]=True   ,		__lowerCAmelCase				:	Optional[int]=32   ,		__lowerCAmelCase				:	Dict=5   ,		__lowerCAmelCase				:	str=4   ,		__lowerCAmelCase				:	Union[str, Any]=37   ,		__lowerCAmelCase				:	Any="gelu"   ,		__lowerCAmelCase				:	str=0.1   ,		__lowerCAmelCase				:	List[Any]=0.1   ,		__lowerCAmelCase				:	Optional[Any]=10   ,		__lowerCAmelCase				:	List[Any]=0.02   ,		__lowerCAmelCase				:	Dict=3   ,		)      ->					List[str]:
         lowercase_     =      parent
         lowercase_     =      vocab_size
         lowercase_     =      batch_size
         lowercase_     =      image_size
         lowercase_     =      patch_size
         lowercase_     =      num_channels
         lowercase_     =      is_training
         lowercase_     =      use_labels
         lowercase_     =      hidden_size
         lowercase_     =      num_hidden_layers
         lowercase_     =      num_attention_heads
         lowercase_     =      intermediate_size
         lowercase_     =      hidden_act
         lowercase_     =      hidden_dropout_prob
         lowercase_     =      attention_probs_dropout_prob
         lowercase_     =      type_sequence_label_size
         lowercase_     =      initializer_range

         # in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
         lowercase_     =      (image_size // patch_size) ** 2
         lowercase_     =      num_patches + 1


   def __UpperCAmelCase       (   self				:	Any)      ->					List[str]:
         lowercase_     =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

         lowercase_     =      None
         if self.use_labels:
               lowercase_     =      ids_tensor([self.batch_size]   ,		self.type_sequence_label_size)

         lowercase_     =      BeitConfig(
             vocab_size=self.vocab_size   ,		image_size=self.image_size   ,		patch_size=self.patch_size   ,		num_channels=self.num_channels   ,		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   ,		is_decoder=__lowerCAmelCase   ,		initializer_range=self.initializer_range   ,		)

         return config, pixel_values, labels


   def __UpperCAmelCase       (   self				:	Any   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	Optional[int])      ->					List[str]:
         lowercase_     =      FlaxBeitModel(config=__lowerCAmelCase)
         lowercase_     =      model(__lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape   ,		(self.batch_size, self.seq_length, self.hidden_size))


   def __UpperCAmelCase       (   self				:	List[Any]   ,		__lowerCAmelCase				:	List[str]   ,		__lowerCAmelCase				:	Tuple   ,		__lowerCAmelCase				:	Tuple)      ->					Union[str, Any]:
         lowercase_     =      FlaxBeitForMaskedImageModeling(config=__lowerCAmelCase)
         lowercase_     =      model(__lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.seq_length - 1, self.vocab_size))


   def __UpperCAmelCase       (   self				:	Any   ,		__lowerCAmelCase				:	List[str]   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	Tuple)      ->					List[str]:
         lowercase_     =      self.type_sequence_label_size
         lowercase_     =      FlaxBeitForImageClassification(config=__lowerCAmelCase)
         lowercase_     =      model(__lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.type_sequence_label_size))

         # test greyscale images
         lowercase_     =      1
         lowercase_     =      FlaxBeitForImageClassification(__lowerCAmelCase)

         lowercase_     =      floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
         lowercase_     =      model(__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Any:
         lowercase_     =      self.prepare_config_and_inputs()
         (
             (
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							
         )     =      config_and_inputs
         lowercase_     =      {"pixel_values": pixel_values}
         return config, inputs_dict





@require_flax
class 							lowercase						(						__lowerCamelCase ,				unittest.TestCase ):
   lowerCamelCase_    					=(
       (FlaxBeitModel, FlaxBeitForImageClassification, FlaxBeitForMaskedImageModeling) if is_flax_available() else ()
   )


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					None:
         lowercase_     =      FlaxBeitModelTester(self)
         lowercase_     =      ConfigTester(self   ,		config_class=__lowerCAmelCase   ,		has_text_modality=__lowerCAmelCase   ,		hidden_size=37)


   def __UpperCAmelCase       (   self				:	int)      ->					Tuple:
         self.config_tester.run_common_tests()


   def __UpperCAmelCase       (   self				:	str)      ->					List[Any]:
         lowercase_ ,							lowercase_     =      self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
               lowercase_     =      model_class(__lowerCAmelCase)
               lowercase_     =      inspect.signature(model.__call__)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               lowercase_     =      [*signature.parameters.keys()]

               lowercase_     =      ["pixel_values"]
               self.assertListEqual(arg_names[:1]   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	List[str])      ->					int:
         lowercase_ ,							lowercase_     =      self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
               with self.subTest(model_class.__name__):
                     lowercase_     =      self._prepare_for_class(__lowerCAmelCase   ,		__lowerCAmelCase)
                     lowercase_     =      model_class(__lowerCAmelCase)

                     @jax.jit
                     def model_jitted(__lowerCAmelCase				:	Optional[Any]   ,		**__lowerCAmelCase				:	Union[str, Any]):
                           return model(pixel_values=__lowerCAmelCase   ,		**__lowerCAmelCase)

                     with self.subTest("JIT Enabled"):
                           lowercase_     =      model_jitted(**__lowerCAmelCase).to_tuple()

                     with self.subTest("JIT Disabled"):
                           with jax.disable_jit():
                                 lowercase_     =      model_jitted(**__lowerCAmelCase).to_tuple()

                     self.assertEqual(len(__lowerCAmelCase)   ,		len(__lowerCAmelCase))
                     for jitted_output, output in zip(__lowerCAmelCase   ,		__lowerCAmelCase):
                           self.assertEqual(jitted_output.shape   ,		output.shape)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					Dict:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					int:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					List[Any]:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase)


   @slow
   def __UpperCAmelCase       (   self				:	Tuple)      ->					Union[str, Any]:
         for model_class_name in self.all_model_classes:
               lowercase_     =      model_class_name.from_pretrained("microsoft/beit-base-patch16-224")
               lowercase_     =      model(np.ones((1, 3, 224, 224)))
               self.assertIsNotNone(__lowerCAmelCase)




def __a (	)	->							Dict:
      '''simple docstring'''


      lowercase_     =      Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
      return image






@require_vision
@require_flax
class 							lowercase						(						unittest.TestCase ):


   @cached_property
   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					Union[str, Any]:
         return BeitImageProcessor.from_pretrained("microsoft/beit-base-patch16-224") if is_vision_available() else None


   @slow
   def __UpperCAmelCase       (   self				:	Dict)      ->					List[str]:
         lowercase_     =      FlaxBeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k")

         lowercase_     =      self.default_image_processor
         lowercase_     =      prepare_img()
         lowercase_     =      image_processor(images=__lowerCAmelCase   ,		return_tensors="np").pixel_values

         # prepare bool_masked_pos
         lowercase_     =      np.ones((1, 196)   ,		dtype=__lowerCAmelCase)

         # forward pass
         lowercase_     =      model(pixel_values=__lowerCAmelCase   ,		bool_masked_pos=__lowerCAmelCase)
         lowercase_     =      outputs.logits

         # verify the logits
         lowercase_     =      (1, 196, 8192)
         self.assertEqual(logits.shape   ,		__lowerCAmelCase)

         lowercase_     =      np.array(
             [[-3.2437, 0.5072, -13.9174], [-3.2456, 0.4948, -13.9401], [-3.2033, 0.5121, -13.8550]])

         self.assertTrue(np.allclose(logits[bool_masked_pos][:3, :3]   ,		__lowerCAmelCase   ,		atol=1e-2))


   @slow
   def __UpperCAmelCase       (   self				:	List[Any])      ->					Tuple:
         lowercase_     =      FlaxBeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224")

         lowercase_     =      self.default_image_processor
         lowercase_     =      prepare_img()
         lowercase_     =      image_processor(images=__lowerCAmelCase   ,		return_tensors="np")

         # forward pass
         lowercase_     =      model(**__lowerCAmelCase)
         lowercase_     =      outputs.logits

         # verify the logits
         lowercase_     =      (1, 1000)
         self.assertEqual(logits.shape   ,		__lowerCAmelCase)

         lowercase_     =      np.array([-1.2385, -1.0987, -1.0108])

         self.assertTrue(np.allclose(logits[0, :3]   ,		__lowerCAmelCase   ,		atol=1e-4))

         lowercase_     =      281
         self.assertEqual(logits.argmax(-1).item()   ,		__lowerCAmelCase)


   @slow
   def __UpperCAmelCase       (   self				:	List[str])      ->					Any:
         lowercase_     =      FlaxBeitForImageClassification.from_pretrained("microsoft/beit-large-patch16-224-pt22k-ft22k")

         lowercase_     =      self.default_image_processor
         lowercase_     =      prepare_img()
         lowercase_     =      image_processor(images=__lowerCAmelCase   ,		return_tensors="np")

         # forward pass
         lowercase_     =      model(**__lowerCAmelCase)
         lowercase_     =      outputs.logits

         # verify the logits
         lowercase_     =      (1, 2_1841)
         self.assertEqual(logits.shape   ,		__lowerCAmelCase)

         lowercase_     =      np.array([1.6881, -0.2787, 0.5901])

         self.assertTrue(np.allclose(logits[0, :3]   ,		__lowerCAmelCase   ,		atol=1e-4))

         lowercase_     =      2396
         self.assertEqual(logits.argmax(-1).item()   ,		__lowerCAmelCase)







'''simple docstring'''

import gc
import unittest

from transformers import CTRLConfig, 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 (
           CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
           CTRLForSequenceClassification,
           CTRLLMHeadModel,
           CTRLModel,
       )





class 							lowercase						:


   def __init__(   self				:	List[Any]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	Any=14   ,		__lowerCAmelCase				:	Optional[Any]=7   ,		__lowerCAmelCase				:	List[str]=True   ,		__lowerCAmelCase				:	Optional[int]=True   ,		__lowerCAmelCase				:	Optional[Any]=True   ,		__lowerCAmelCase				:	Optional[Any]=True   ,		__lowerCAmelCase				:	Optional[Any]=True   ,		__lowerCAmelCase				:	Any=99   ,		__lowerCAmelCase				:	Tuple=32   ,		__lowerCAmelCase				:	Union[str, Any]=5   ,		__lowerCAmelCase				:	str=4   ,		__lowerCAmelCase				:	Dict=37   ,		__lowerCAmelCase				:	Optional[int]="gelu"   ,		__lowerCAmelCase				:	int=0.1   ,		__lowerCAmelCase				:	Tuple=0.1   ,		__lowerCAmelCase				:	str=512   ,		__lowerCAmelCase				:	Optional[Any]=16   ,		__lowerCAmelCase				:	Optional[int]=2   ,		__lowerCAmelCase				:	str=0.02   ,		__lowerCAmelCase				:	str=3   ,		__lowerCAmelCase				:	Tuple=4   ,		__lowerCAmelCase				:	Union[str, Any]=None   ,		)      ->					List[Any]:
         lowercase_     =      parent
         lowercase_     =      batch_size
         lowercase_     =      seq_length
         lowercase_     =      is_training
         lowercase_     =      use_token_type_ids
         lowercase_     =      use_input_mask
         lowercase_     =      use_labels
         lowercase_     =      use_mc_token_ids
         lowercase_     =      vocab_size
         lowercase_     =      hidden_size
         lowercase_     =      num_hidden_layers
         lowercase_     =      num_attention_heads
         lowercase_     =      intermediate_size
         lowercase_     =      hidden_act
         lowercase_     =      hidden_dropout_prob
         lowercase_     =      attention_probs_dropout_prob
         lowercase_     =      max_position_embeddings
         lowercase_     =      type_vocab_size
         lowercase_     =      type_sequence_label_size
         lowercase_     =      initializer_range
         lowercase_     =      num_labels
         lowercase_     =      num_choices
         lowercase_     =      scope
         lowercase_     =      self.vocab_size - 1


   def __UpperCAmelCase       (   self				:	Tuple)      ->					int:
         lowercase_     =      ids_tensor([self.batch_size, self.seq_length]   ,		self.vocab_size)

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

         lowercase_     =      None
         if self.use_token_type_ids:
               lowercase_     =      ids_tensor([self.batch_size, self.seq_length]   ,		self.type_vocab_size)

         lowercase_     =      None
         if self.use_mc_token_ids:
               lowercase_     =      ids_tensor([self.batch_size, self.num_choices]   ,		self.seq_length)

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

         lowercase_     =      self.get_config()

         lowercase_     =      ids_tensor([self.num_hidden_layers, self.num_attention_heads]   ,		2)

         return (
             config,
             input_ids,
             input_mask,
             head_mask,
             token_type_ids,
             mc_token_ids,
             sequence_labels,
             token_labels,
             choice_labels,
         )


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					int:
         return CTRLConfig(
             vocab_size=self.vocab_size   ,		n_embd=self.hidden_size   ,		n_layer=self.num_hidden_layers   ,		n_head=self.num_attention_heads   ,		n_positions=self.max_position_embeddings   ,		pad_token_id=self.pad_token_id   ,		)


   def __UpperCAmelCase       (   self				:	Union[str, Any]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Tuple   ,		__lowerCAmelCase				:	Union[str, Any]   ,		*__lowerCAmelCase				:	Tuple)      ->					List[str]:
         lowercase_     =      CTRLModel(config=__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()

         model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase   ,		head_mask=__lowerCAmelCase)
         model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase)
         lowercase_     =      model(__lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape   ,		(self.batch_size, self.seq_length, self.hidden_size))
         self.parent.assertEqual(len(result.past_key_values)   ,		config.n_layer)


   def __UpperCAmelCase       (   self				:	List[Any]   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	int   ,		__lowerCAmelCase				:	Dict   ,		*__lowerCAmelCase				:	int)      ->					int:
         lowercase_     =      CTRLLMHeadModel(__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()

         lowercase_     =      model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase   ,		labels=__lowerCAmelCase)
         self.parent.assertEqual(result.loss.shape   ,		())
         self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.seq_length, self.vocab_size))


   def __UpperCAmelCase       (   self				:	Dict)      ->					int:
         lowercase_     =      self.prepare_config_and_inputs()

         (
             (
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							
         )     =      config_and_inputs

         lowercase_     =      {"input_ids": input_ids, "token_type_ids": token_type_ids, "head_mask": head_mask}

         return config, inputs_dict


   def __UpperCAmelCase       (   self				:	Any   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	int   ,		__lowerCAmelCase				:	List[str]   ,		*__lowerCAmelCase				:	List[Any])      ->					int:
         lowercase_     =      self.num_labels
         lowercase_     =      CTRLForSequenceClassification(__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()
         lowercase_     =      ids_tensor([self.batch_size]   ,		self.type_sequence_label_size)
         lowercase_     =      model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase   ,		labels=__lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.num_labels))





@require_torch
class 							lowercase						(						__lowerCamelCase ,				__lowerCamelCase ,				__lowerCamelCase ,				unittest.TestCase ):
   lowerCamelCase_    					=(CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else ()
   lowerCamelCase_    					=(CTRLLMHeadModel,) if is_torch_available() else ()
   lowerCamelCase_    					=(
       {
           'feature-extraction': CTRLModel,
           'text-classification': CTRLForSequenceClassification,
           'text-generation': CTRLLMHeadModel,
           'zero-shot': CTRLForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   lowerCamelCase_    					=True
   lowerCamelCase_    					=False
   lowerCamelCase_    					=False


   def __UpperCAmelCase       (   self				:	Tuple   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	str   ,		__lowerCAmelCase				:	List[Any]   ,		__lowerCAmelCase				:	int)      ->					Optional[int]:
         if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
               # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
               # `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
               # config could not be created.
               return True

         return False


   def __UpperCAmelCase       (   self				:	str)      ->					Tuple:
         lowercase_     =      CTRLModelTester(self)
         lowercase_     =      ConfigTester(self   ,		config_class=__lowerCAmelCase   ,		n_embd=37)


   def __UpperCAmelCase       (   self				:	Dict)      ->					Optional[Any]:
         super().tearDown()
         # clean-up as much as possible GPU memory occupied by PyTorch
         gc.collect()
         torch.cuda.empty_cache()


   def __UpperCAmelCase       (   self				:	str)      ->					List[Any]:
         self.config_tester.run_common_tests()


   def __UpperCAmelCase       (   self				:	Any)      ->					List[Any]:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_model(*__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Dict:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_lm_head_model(*__lowerCAmelCase)


   @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests.")
   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					Optional[Any]:
         pass


   @slow
   def __UpperCAmelCase       (   self				:	Dict)      ->					List[str]:
         for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowercase_     =      CTRLModel.from_pretrained(__lowerCAmelCase)
               self.assertIsNotNone(__lowerCAmelCase)


   @unittest.skip("The model doesn't support left padding")  # and it's not used enough to be worth fixing :)
   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Dict:
         pass





@require_torch
class 							lowercase						(						unittest.TestCase ):


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					Any:
         super().tearDown()
         # clean-up as much as possible GPU memory occupied by PyTorch
         gc.collect()
         torch.cuda.empty_cache()


   @slow
   def __UpperCAmelCase       (   self				:	int)      ->					Any:
         lowercase_     =      CTRLLMHeadModel.from_pretrained("ctrl")
         model.to(__lowerCAmelCase)
         lowercase_     =      torch.tensor(
             [[1_1859, 0, 1611, 8]]   ,		dtype=torch.long   ,		device=__lowerCAmelCase)  # Legal the president is
         lowercase_     =      [
             1_1859,
             0,
             1611,
             8,
             5,
             150,
             2_6449,
             2,
             19,
             348,
             469,
             3,
             2595,
             48,
             2_0740,
             24_6533,
             24_6533,
             19,
             30,
             5,
         ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

         lowercase_     =      model.generate(__lowerCAmelCase   ,		do_sample=__lowerCAmelCase)
         self.assertListEqual(output_ids[0].tolist()   ,		__lowerCAmelCase)






