




"""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 	UpperCAmelCase_  :




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




     '''simple docstring'''

     A__       =				parent
     A__       =				batch_size
     A__       =				seq_length
     A__       =				is_training
     A__       =				use_token_type_ids
     A__       =				use_input_mask
     A__       =				use_labels
     A__       =				use_mc_token_ids
     A__       =				vocab_size
     A__       =				hidden_size
     A__       =				num_hidden_layers
     A__       =				num_attention_heads
     A__       =				intermediate_size
     A__       =				hidden_act
     A__       =				hidden_dropout_prob
     A__       =				attention_probs_dropout_prob
     A__       =				max_position_embeddings
     A__       =				type_vocab_size
     A__       =				type_sequence_label_size
     A__       =				initializer_range
     A__       =				num_labels
     A__       =				num_choices
     A__       =				scope
     A__       =				self.vocab_size - 1




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




     '''simple docstring'''

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

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

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

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

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

     A__       =				self.get_config()

     A__       =				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 							__magic_name__							(    self						:       Optional[int]      )      ->							List[Any]:




     '''simple docstring'''

     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 							__magic_name__							(    self						:       Union[str, Any]	, snake_case_						:       Any	, snake_case_						:       Tuple	, snake_case_						:       Any	, snake_case_						:       List[Any]	, snake_case_						:       Union[str, Any]	, *snake_case_						:       Dict      )      ->							Optional[int]:




     '''simple docstring'''

     A__       =				CTRLModel(config=snake_case_      )
     model.to(snake_case_      )
     model.eval()

     model(snake_case_	, token_type_ids=snake_case_	, head_mask=snake_case_      )
     model(snake_case_	, token_type_ids=snake_case_      )
     A__       =				model(snake_case_      )
     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 							__magic_name__							(    self						:       Optional[Any]	, snake_case_						:       Union[str, Any]	, snake_case_						:       Tuple	, snake_case_						:       Union[str, Any]	, snake_case_						:       Union[str, Any]	, snake_case_						:       Optional[int]	, *snake_case_						:       Any      )      ->							Any:




     '''simple docstring'''

     A__       =				CTRLLMHeadModel(snake_case_      )
     model.to(snake_case_      )
     model.eval()

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




    def 							__magic_name__							(    self						:       Dict      )      ->							int:




     '''simple docstring'''

     A__       =				self.prepare_config_and_inputs()

     (
         (
         A__						
     ),      (
         A__						
     ),      (
         A__						
     ),      (
         A__						
     ),      (
         A__						
     ),      (
         A__						
     ),      (
         A__						
     ),      (
         A__						
     ),      (
         A__						
     ),      						
     )       =				config_and_inputs

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

     return config, inputs_dict




    def 							__magic_name__							(    self						:       List[str]	, snake_case_						:       Tuple	, snake_case_						:       Optional[Any]	, snake_case_						:       int	, snake_case_						:       Any	, *snake_case_						:       int      )      ->							List[Any]:




     '''simple docstring'''

     A__       =				self.num_labels
     A__       =				CTRLForSequenceClassification(snake_case_      )
     model.to(snake_case_      )
     model.eval()
     A__       =				ids_tensor([self.batch_size]	, self.type_sequence_label_size      )
     A__       =				model(snake_case_	, token_type_ids=snake_case_	, labels=snake_case_      )
     self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.num_labels)      )






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




    def 							__magic_name__							(    self						:       Dict	, snake_case_						:       Optional[int]	, snake_case_						:       str	, snake_case_						:       Any	, snake_case_						:       List[str]	, snake_case_						:       Optional[Any]      )      ->							Tuple:




     '''simple docstring'''

     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 							__magic_name__							(    self						:       Any      )      ->							Optional[int]:




     '''simple docstring'''

     A__       =				CTRLModelTester(self      )
     A__       =				ConfigTester(self	, config_class=snake_case_	, n_embd=37      )




    def 							__magic_name__							(    self						:       Tuple      )      ->							str:




     '''simple docstring'''

     super().tearDown()
     # clean-up as much as possible GPU memory occupied by PyTorch
     gc.collect()
     torch.cuda.empty_cache()




    def 							__magic_name__							(    self						:       int      )      ->							Tuple:




     '''simple docstring'''

     self.config_tester.run_common_tests()




    def 							__magic_name__							(    self						:       str      )      ->							str:




     '''simple docstring'''

     A__       =				self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_ctrl_model(*snake_case_      )




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




     '''simple docstring'''

     A__       =				self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_lm_head_model(*snake_case_      )




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




     '''simple docstring'''

     pass




    @slow
    def 							__magic_name__							(    self						:       Any      )      ->							Tuple:




     '''simple docstring'''

     for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      A__       =				CTRLModel.from_pretrained(snake_case_      )
      self.assertIsNotNone(snake_case_      )




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




     '''simple docstring'''

     pass






@require_torch
class 	UpperCAmelCase_  (						unittest.TestCase							):




    def 							__magic_name__							(    self						:       Any      )      ->							Any:




     '''simple docstring'''

     super().tearDown()
     # clean-up as much as possible GPU memory occupied by PyTorch
     gc.collect()
     torch.cuda.empty_cache()




    @slow
    def 							__magic_name__							(    self						:       int      )      ->							int:




     '''simple docstring'''

     A__       =				CTRLLMHeadModel.from_pretrained("ctrl"      )
     model.to(snake_case_      )
     A__       =				torch.tensor(
         [[11_859, 0, 1_611, 8]]	, dtype=torch.long	, device=snake_case_      )  # Legal the president is
     A__       =				[
         11_859,
         0,
         1_611,
         8,
         5,
         150,
         26_449,
         2,
         19,
         348,
         469,
         3,
         2_595,
         48,
         20_740,
         246_533,
         246_533,
         19,
         30,
         5,
     ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

     A__       =				model.generate(snake_case_	, do_sample=snake_case_      )
     self.assertListEqual(output_ids[0].tolist()	, snake_case_      )













import inspect
import unittest

from transformers import MobileNetVaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import MobileNetVaForImageClassification, MobileNetVaModel
							from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import MobileNetVaImageProcessor
class       _UpperCAmelCase					(       A__	):

				"""simple docstring"""




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			self.config_class(**self.inputs_dict  )
								self.parent.assertTrue(hasattr(lowerCamelCase,  '''tf_padding'''  )  )
								self.parent.assertTrue(hasattr(lowerCamelCase,  '''depth_multiplier'''  )  )



class       _UpperCAmelCase					:

				"""simple docstring"""




				def __init__(     self						:    List[str],  lowerCamelCase						:    List[str],  lowerCamelCase						:    Optional[Any]=13,  lowerCamelCase						:    List[str]=3,  lowerCamelCase						:    List[str]=32,  lowerCamelCase						:    Union[str, Any]=0.25,  lowerCamelCase						:    int=8,  lowerCamelCase						:    Dict=True,  lowerCamelCase						:    Optional[int]=1_024,  lowerCamelCase						:    List[str]=32,  lowerCamelCase						:    Optional[int]="relu6",  lowerCamelCase						:    Optional[int]=0.1,  lowerCamelCase						:    Optional[Any]=0.02,  lowerCamelCase						:    List[Any]=True,  lowerCamelCase						:    Any=True,  lowerCamelCase						:    Dict=10,  lowerCamelCase						:    Optional[int]=None,  ):

								'''simple docstring'''
								lowercase__    =			parent
								lowercase__    =			batch_size
								lowercase__    =			num_channels
								lowercase__    =			image_size
								lowercase__    =			depth_multiplier
								lowercase__    =			min_depth
								lowercase__    =			tf_padding
								lowercase__    =			int(last_hidden_size * depth_multiplier  )
								lowercase__    =			output_stride
								lowercase__    =			hidden_act
								lowercase__    =			classifier_dropout_prob
								lowercase__    =			use_labels
								lowercase__    =			is_training
								lowercase__    =			num_labels
								lowercase__    =			initializer_range
								lowercase__    =			scope




				def 				lowercase__   (     self						:    Any  ):

								'''simple docstring'''
								lowercase__    =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

								lowercase__    =			None
								lowercase__    =			None
								if self.use_labels:
												lowercase__    =			ids_tensor([self.batch_size],  self.num_labels  )
												lowercase__    =			ids_tensor([self.batch_size, self.image_size, self.image_size],  self.num_labels  )

								lowercase__    =			self.get_config()

								return config, pixel_values, labels, pixel_labels




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								return MobileNetVaConfig(
								    num_channels=self.num_channels,  image_size=self.image_size,  depth_multiplier=self.depth_multiplier,  min_depth=self.min_depth,  tf_padding=self.tf_padding,  hidden_act=self.hidden_act,  classifier_dropout_prob=self.classifier_dropout_prob,  initializer_range=self.initializer_range,  )




				def 				lowercase__   (     self						:    List[str],  lowerCamelCase						:    List[str],  lowerCamelCase						:    Union[str, Any],  lowerCamelCase						:    Tuple,  lowerCamelCase						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			MobileNetVaModel(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase  )
								self.parent.assertEqual(
								    result.last_hidden_state.shape,  (
								        self.batch_size,
								        self.last_hidden_size,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    ),  )




				def 				lowercase__   (     self						:    str,  lowerCamelCase						:    str,  lowerCamelCase						:    List[str],  lowerCamelCase						:    List[Any],  lowerCamelCase						:    str  ):

								'''simple docstring'''
								lowercase__    =			self.num_labels
								lowercase__    =			MobileNetVaForImageClassification(lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase,  labels=lowerCamelCase  )
								self.parent.assertEqual(result.logits.shape,  (self.batch_size, self.num_labels)  )




				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								lowercase__    =			self.prepare_config_and_inputs()
								lowercase__ ,						lowercase__ ,						lowercase__ ,						lowercase__    =			config_and_inputs
								lowercase__    =			{'''pixel_values''': pixel_values}
								return config, inputs_dict



@require_torch
class       _UpperCAmelCase					(       A__		,A__		,unittest.TestCase	):

				"""simple docstring"""




				lowercase__											=       (MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
				lowercase__											=       (
				    {"""feature-extraction""": MobileNetVaModel, """image-classification""": MobileNetVaForImageClassification}
				    if is_torch_available()
				    else {}
				)

				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			MobileNetVaModelTester(self  )
								lowercase__    =			MobileNetVaConfigTester(self,  config_class=lowerCamelCase,  has_text_modality=lowerCamelCase  )




				def 				lowercase__   (     self						:    Any  ):

								'''simple docstring'''
								self.config_tester.run_common_tests()




				@unittest.skip(reason='''MobileNetV1 does not use inputs_embeds'''  )
				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								pass




				@unittest.skip(reason='''MobileNetV1 does not support input and output embeddings'''  )
				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								pass




				@unittest.skip(reason='''MobileNetV1 does not output attentions'''  )
				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								pass




				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								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.forward  )
												# 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 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCamelCase  )




				def 				lowercase__   (     self						:    List[Any]  ):

								'''simple docstring'''
								def check_hidden_states_output(lowerCamelCase						:    str,  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    List[str]  ):
												lowercase__    =			model_class(lowerCamelCase  )
												model.to(lowerCamelCase  )
												model.eval()

												with torch.no_grad():
																lowercase__    =			model(**self._prepare_for_class(lowerCamelCase,  lowerCamelCase  )  )

												lowercase__    =			outputs.hidden_states

												lowercase__    =			26
												self.assertEqual(len(lowerCamelCase  ),  lowerCamelCase  )

								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
												lowercase__    =			True
												check_hidden_states_output(lowerCamelCase,  lowerCamelCase,  lowerCamelCase  )

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												lowercase__    =			True

												check_hidden_states_output(lowerCamelCase,  lowerCamelCase,  lowerCamelCase  )




				def 				lowercase__   (     self						:    Any  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*lowerCamelCase  )




				@slow
				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowercase__    =			MobileNetVaModel.from_pretrained(lowerCamelCase  )
												self.assertIsNotNone(lowerCamelCase  )






def   a			(						):






				'''simple docstring'''
				lowercase__    =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
				return image




@require_torch
@require_vision
class       _UpperCAmelCase					(       unittest.TestCase	):

				"""simple docstring"""




				@cached_property
				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								return (
								    MobileNetVaImageProcessor.from_pretrained('''google/mobilenet_v1_1.0_224'''  ) if is_vision_available() else None
								)




				@slow
				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			MobileNetVaForImageClassification.from_pretrained('''google/mobilenet_v1_1.0_224'''  ).to(lowerCamelCase  )

								lowercase__    =			self.default_image_processor
								lowercase__    =			prepare_img()
								lowercase__    =			image_processor(images=lowerCamelCase,  return_tensors='''pt'''  ).to(lowerCamelCase  )

								# forward pass
								with torch.no_grad():
												lowercase__    =			model(**lowerCamelCase  )

								# verify the logits
								lowercase__    =			torch.Size((1, 1_001)  )
								self.assertEqual(outputs.logits.shape,  lowerCamelCase  )

								lowercase__    =			torch.tensor([-4.1739, -1.1233, 3.1205]  ).to(lowerCamelCase  )

								self.assertTrue(torch.allclose(outputs.logits[0, :3],  lowerCamelCase,  atol=1E-4  )  )




