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




			"""simple docstring"""







			def __init__(				self						:					Any       ,   _snake_case						:					Optional[Any]       ,   _snake_case						:					List[str]=14       ,   _snake_case						:					Any=7       ,   _snake_case						:					List[Any]=True       ,   _snake_case						:					List[Any]=True       ,   _snake_case						:					Dict=True       ,   _snake_case						:					Union[str, Any]=True       ,   _snake_case						:					int=True       ,   _snake_case						:					Dict=99       ,   _snake_case						:					Tuple=32       ,   _snake_case						:					List[Any]=5       ,   _snake_case						:					str=4       ,   _snake_case						:					str=37       ,   _snake_case						:					Tuple="gelu"       ,   _snake_case						:					str=0.1       ,   _snake_case						:					Optional[int]=0.1       ,   _snake_case						:					Optional[int]=512       ,   _snake_case						:					List[str]=16       ,   _snake_case						:					Tuple=2       ,   _snake_case						:					List[str]=0.0_2       ,   _snake_case						:					Tuple=3       ,   _snake_case						:					int=4       ,   _snake_case						:					Any=None       ,   )      -> 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      lowerCamelCase__     (				self						:					Union[str, Any]	)      -> 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      lowerCamelCase__     (				self						:					Dict	)      -> Optional[int]:







								"""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      lowerCamelCase__     (				self						:					Union[str, Any]       ,   _snake_case						:					Optional[Any]       ,   _snake_case						:					Union[str, Any]       ,   _snake_case						:					List[Any]       ,   _snake_case						:					Optional[int]       ,   _snake_case						:					List[str]       ,   *_snake_case						:					int	)      -> List[Any]:







								"""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      lowerCamelCase__     (				self						:					Optional[int]       ,   _snake_case						:					int       ,   _snake_case						:					List[Any]       ,   _snake_case						:					Optional[int]       ,   _snake_case						:					List[Any]       ,   _snake_case						:					List[Any]       ,   *_snake_case						:					List[str]	)      -> Optional[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      lowerCamelCase__     (				self						:					Any	)      -> Tuple:







								"""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      lowerCamelCase__     (				self						:					str       ,   _snake_case						:					List[Any]       ,   _snake_case						:					Dict       ,   _snake_case						:					str       ,   _snake_case						:					int       ,   *_snake_case						:					List[Any]	)      -> Dict:







								"""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 __lowerCAmelCase				(					_lowercase     ,				_lowercase     ,				_lowercase     ,				unittest.TestCase      ):




			"""simple docstring"""







			snake_case	      =				(CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else ()
			snake_case	      =				(CTRLLMHeadModel,) if is_torch_available() else ()
			snake_case	      =				(
			    {
			        "feature-extraction": CTRLModel,
			        "text-classification": CTRLForSequenceClassification,
			        "text-generation": CTRLLMHeadModel,
			        "zero-shot": CTRLForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			snake_case	      =				True
			snake_case	      =				False
			snake_case	      =				False




			def      lowerCamelCase__     (				self						:					List[str]       ,   _snake_case						:					str       ,   _snake_case						:					List[str]       ,   _snake_case						:					List[Any]       ,   _snake_case						:					List[Any]       ,   _snake_case						:					str	)      -> int:







								"""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      lowerCamelCase__     (				self						:					Union[str, Any]	)      -> Optional[Any]:







								"""simple docstring"""
								A_				 =						CTRLModelTester(self	)
								A_				 =						ConfigTester(self       ,   config_class=_snake_case       ,   n_embd=37	)




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







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




			def      lowerCamelCase__     (				self						:					str	)      -> Tuple:







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




			def      lowerCamelCase__     (				self						:					Optional[Any]	)      -> Any:







								"""simple docstring"""
								A_				 =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_ctrl_model(*_snake_case	)




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







								"""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      lowerCamelCase__     (				self						:					Dict	)      -> Any:







								"""simple docstring"""
								pass




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







								"""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      lowerCamelCase__     (				self						:					str	)      -> int:







								"""simple docstring"""
								pass





@require_torch
class __lowerCAmelCase				(					unittest.TestCase      ):




			"""simple docstring"""







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







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






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







								"""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	)






"""simple docstring"""





import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 torch import nn

		from transformers import RegNetForImageClassification, RegNetModel
		from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor



class __lowerCAmelCase				:




			"""simple docstring"""







			def __init__(				self						:					Optional[int]       ,   _snake_case						:					Any       ,   _snake_case						:					int=3       ,   _snake_case						:					List[Any]=32       ,   _snake_case						:					str=3       ,   _snake_case						:					Any=10       ,   _snake_case						:					List[Any]=[10, 20, 30, 40]       ,   _snake_case						:					Dict=[1, 1, 2, 1]       ,   _snake_case						:					Dict=True       ,   _snake_case						:					Any=True       ,   _snake_case						:					List[str]="relu"       ,   _snake_case						:					List[Any]=3       ,   _snake_case						:					List[str]=None       ,   )      -> int:







								"""simple docstring"""
								A_				 =						parent
								A_				 =						batch_size
								A_				 =						image_size
								A_				 =						num_channels
								A_				 =						embeddings_size
								A_				 =						hidden_sizes
								A_				 =						depths
								A_				 =						is_training
								A_				 =						use_labels
								A_				 =						hidden_act
								A_				 =						num_labels
								A_				 =						scope
								A_				 =						len(_snake_case	)




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







								"""simple docstring"""
								A_				 =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

								A_				 =						self.get_config()

								return config, pixel_values, labels




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







								"""simple docstring"""
								return RegNetConfig(
								    num_channels=self.num_channels       ,   embeddings_size=self.embeddings_size       ,   hidden_sizes=self.hidden_sizes       ,   depths=self.depths       ,   hidden_act=self.hidden_act       ,   num_labels=self.num_labels       ,   )




			def      lowerCamelCase__     (				self						:					Union[str, Any]       ,   _snake_case						:					str       ,   _snake_case						:					Tuple       ,   _snake_case						:					Tuple	)      -> List[str]:







								"""simple docstring"""
								A_				 =						RegNetModel(config=_snake_case	)
								model.to(_snake_case	)
								model.eval()
								A_				 =						model(_snake_case	)
								# expected last hidden states: B, C, H // 32, W // 32
								self.parent.assertEqual(
								    result.last_hidden_state.shape       ,   (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)       ,   )




			def      lowerCamelCase__     (				self						:					Dict       ,   _snake_case						:					Tuple       ,   _snake_case						:					Optional[Any]       ,   _snake_case						:					Optional[Any]	)      -> Optional[Any]:







								"""simple docstring"""
								A_				 =						self.num_labels
								A_				 =						RegNetForImageClassification(_snake_case	)
								model.to(_snake_case	)
								model.eval()
								A_				 =						model(_snake_case       ,   labels=_snake_case	)
								self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.num_labels)	)






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







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





@require_torch
class __lowerCAmelCase				(					_lowercase     ,				_lowercase     ,				unittest.TestCase      ):




			"""simple docstring"""







			snake_case	      =				(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
			snake_case	      =				(
			    {"feature-extraction": RegNetModel, "image-classification": RegNetForImageClassification}
			    if is_torch_available()
			    else {}
			)

			snake_case	      =				False
			snake_case	      =				False
			snake_case	      =				False
			snake_case	      =				False




			def      lowerCamelCase__     (				self						:					str	)      -> str:







								"""simple docstring"""
								A_				 =						RegNetModelTester(self	)
								A_				 =						ConfigTester(self       ,   config_class=_snake_case       ,   has_text_modality=_snake_case	)




			def      lowerCamelCase__     (				self						:					Tuple	)      -> List[Any]:







								"""simple docstring"""
								self.create_and_test_config_common_properties()
								self.config_tester.create_and_test_config_to_json_string()
								self.config_tester.create_and_test_config_to_json_file()
								self.config_tester.create_and_test_config_from_and_save_pretrained()
								self.config_tester.create_and_test_config_with_num_labels()
								self.config_tester.check_config_can_be_init_without_params()
								self.config_tester.check_config_arguments_init()




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







								"""simple docstring"""
								return




			@unittest.skip(reason="RegNet does not use inputs_embeds"	)
			def      lowerCamelCase__     (				self						:					int	)      -> Optional[Any]:







								"""simple docstring"""
								pass




			@unittest.skip(reason="RegNet does not support input and output embeddings"	)
			def      lowerCamelCase__     (				self						:					int	)      -> Union[str, Any]:







								"""simple docstring"""
								pass




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







								"""simple docstring"""
								A_ ,    A_				 =						self.model_tester.prepare_config_and_inputs_for_common()

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

													A_				 =						["pixel_values"]
													self.assertListEqual(arg_names[:1]       ,   _snake_case	)




			def      lowerCamelCase__     (				self						:					Any	)      -> int:







								"""simple docstring"""
								A_				 =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case	)




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







								"""simple docstring"""
								A_ ,    A_				 =						self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
													A_				 =						model_class(config=_snake_case	)
													for name, module in model.named_modules():
																		if isinstance(_snake_case       ,   (nn.BatchNormad, nn.GroupNorm)	):
																							self.assertTrue(
																							    torch.all(module.weight == 1	)       ,   msg=F'Parameter {name} of model {model_class} seems not properly initialized'       ,   )
																							self.assertTrue(
																							    torch.all(module.bias == 0	)       ,   msg=F'Parameter {name} of model {model_class} seems not properly initialized'       ,   )




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







								"""simple docstring"""
								def check_hidden_states_output(_snake_case						:					Tuple       ,   _snake_case						:					Optional[int]       ,   _snake_case						:					Optional[int]	):
													A_				 =						model_class(_snake_case	)
													model.to(_snake_case	)
													model.eval()

													with torch.no_grad():
																		A_				 =						model(**self._prepare_for_class(_snake_case       ,   _snake_case	)	)

													A_				 =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													A_				 =						self.model_tester.num_stages
													self.assertEqual(len(_snake_case	)       ,   expected_num_stages + 1	)

													# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
													self.assertListEqual(
													    list(hidden_states[0].shape[-2:]	)       ,   [self.model_tester.image_size // 2, self.model_tester.image_size // 2]       ,   )

								A_ ,    A_				 =						self.model_tester.prepare_config_and_inputs_for_common()
								A_				 =						["basic", "bottleneck"]
								for model_class in self.all_model_classes:
													for layer_type in layers_type:
																		A_				 =						layer_type
																		A_				 =						True
																		check_hidden_states_output(_snake_case       ,   _snake_case       ,   _snake_case	)

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

																		check_hidden_states_output(_snake_case       ,   _snake_case       ,   _snake_case	)




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







								"""simple docstring"""
								A_				 =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_snake_case	)






			@slow
			def      lowerCamelCase__     (				self						:					Optional[Any]	)      -> int:







								"""simple docstring"""
								for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													A_				 =						RegNetModel.from_pretrained(_snake_case	)
													self.assertIsNotNone(_snake_case	)





def 							A_     ():

					'''simple docstring'''





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




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




			"""simple docstring"""







			@cached_property
			def      lowerCamelCase__     (				self						:					Union[str, Any]	)      -> int:







								"""simple docstring"""
								return (
								    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)
								    if is_vision_available()
								    else None
								)






			@slow
			def      lowerCamelCase__     (				self						:					str	)      -> List[Any]:







								"""simple docstring"""
								A_				 =						RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(_snake_case	)

								A_				 =						self.default_image_processor
								A_				 =						prepare_img()
								A_				 =						image_processor(images=_snake_case       ,   return_tensors="pt"	).to(_snake_case	)

								# forward pass
								with torch.no_grad():
													A_				 =						model(**_snake_case	)

								# verify the logits
								A_				 =						torch.Size((1, 1_000)	)
								self.assertEqual(outputs.logits.shape       ,   _snake_case	)

								A_				 =						torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]	).to(_snake_case	)

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




