



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 							UpperCAmelCase				:




	'''simple docstring'''





	def __init__(	self :			int							,A :			List[Any]							,A :			int=3							,A :			Optional[Any]=32							,A :			Any=3							,A :			Optional[Any]=10							,A :			Dict=[10, 20, 30, 40]							,A :			Optional[int]=[1, 1, 2, 1]							,A :			List[str]=True							,A :			List[Any]=True							,A :			Tuple="relu"							,A :			Optional[int]=3							,A :			List[str]=None							,):
					__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(UpperCamelCase__			)






	def     UpperCamelCase_  (	self :			Tuple			):
					__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     UpperCamelCase_  (	self :			Optional[Any]			):
					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     UpperCamelCase_  (	self :			List[Any]							,A :			Any							,A :			List[str]							,A :			Dict			):
					__A             =			RegNetModel(config=UpperCamelCase__			)
					model.to(UpperCamelCase__			)
					model.eval()
					__A             =			model(UpperCamelCase__			)
					# 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     UpperCamelCase_  (	self :			Any							,A :			Optional[Any]							,A :			Optional[Any]							,A :			Tuple			):
					__A             =			self.num_labels
					__A             =			RegNetForImageClassification(UpperCamelCase__			)
					model.to(UpperCamelCase__			)
					model.eval()
					__A             =			model(UpperCamelCase__							,labels=UpperCamelCase__			)
					self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.num_labels)			)







	def     UpperCamelCase_  (	self :			Optional[Any]			):
					__A             =			self.prepare_config_and_inputs()
					__A             =			config_and_inputs
					__A             =			{'''pixel_values''': pixel_values}
					return config, inputs_dict





@require_torch
class 							UpperCAmelCase				(  __SCREAMING_SNAKE_CASE      ,      __SCREAMING_SNAKE_CASE      ,      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     UpperCamelCase_  (	self :			Optional[int]			):
					__A             =			RegNetModelTester(self			)
					__A             =			ConfigTester(self							,config_class=UpperCamelCase__							,has_text_modality=UpperCamelCase__			)






	def     UpperCamelCase_  (	self :			Tuple			):
					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     UpperCamelCase_  (	self :			Dict			):
					return






	@unittest.skip(reason="RegNet does not use inputs_embeds"			)
	def     UpperCamelCase_  (	self :			Optional[Any]			):
					pass






	@unittest.skip(reason="RegNet does not support input and output embeddings"			)
	def     UpperCamelCase_  (	self :			List[Any]			):
					pass






	def     UpperCamelCase_  (	self :			Optional[Any]			):
					__A             =			self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									__A             =			model_class(UpperCamelCase__			)
									__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]							,UpperCamelCase__			)






	def     UpperCamelCase_  (	self :			Optional[Any]			):
					__A             =			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*UpperCamelCase__			)






	def     UpperCamelCase_  (	self :			Optional[int]			):
					__A             =			self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									__A             =			model_class(config=UpperCamelCase__			)
									for name, module in model.named_modules():
													if isinstance(UpperCamelCase__							,(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     UpperCamelCase_  (	self :			List[str]			):







					def check_hidden_states_output(A :			str							,A :			Optional[Any]							,A :			Union[str, Any]			):
									__A             =			model_class(UpperCamelCase__			)
									model.to(UpperCamelCase__			)
									model.eval()

									with torch.no_grad():
													__A             =			model(**self._prepare_for_class(UpperCamelCase__							,UpperCamelCase__			)			)

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

									__A             =			self.model_tester.num_stages
									self.assertEqual(len(UpperCamelCase__			)							,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             =			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(UpperCamelCase__							,UpperCamelCase__							,UpperCamelCase__			)

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

													check_hidden_states_output(UpperCamelCase__							,UpperCamelCase__							,UpperCamelCase__			)






	def     UpperCamelCase_  (	self :			List[str]			):
					__A             =			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__			)







	@slow
	def     UpperCamelCase_  (	self :			List[Any]			):







					for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A             =			RegNetModel.from_pretrained(UpperCamelCase__			)
									self.assertIsNotNone(UpperCamelCase__			)





def 						UpperCAmelCase      (     )		->     str:







				"""simple docstring"""



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





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




	'''simple docstring'''





	@cached_property
	def     UpperCamelCase_  (	self :			Union[str, Any]			):
					return (
					    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
					    if is_vision_available()
					    else None
					)







	@slow
	def     UpperCamelCase_  (	self :			Any			):
					__A             =			RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			).to(UpperCamelCase__			)

					__A             =			self.default_image_processor
					__A             =			prepare_img()
					__A             =			image_processor(images=UpperCamelCase__							,return_tensors="pt"			).to(UpperCamelCase__			)

					# forward pass
					with torch.no_grad():
									__A             =			model(**UpperCamelCase__			)

					# verify the logits
					__A             =			torch.Size((1, 10_00)			)
					self.assertEqual(outputs.logits.shape							,UpperCamelCase__			)

					__A             =			torch.tensor([-0.41_80, -1.50_51, -3.48_36]			).to(UpperCamelCase__			)

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


import json
import os
import unittest

from transformers.models.ctrl.tokenization_ctrl import VOCAB_FILES_NAMES, CTRLTokenizer

from ...test_tokenization_common import TokenizerTesterMixin





class 							UpperCAmelCase				(  __SCREAMING_SNAKE_CASE      ,      unittest.TestCase  ):




	'''simple docstring'''





	snake_case_    =					CTRLTokenizer
	snake_case_    =					False
	snake_case_    =					False






	def     UpperCamelCase_  (	self :			Dict			):
					super().setUp()

					# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
					__A             =			["adapt", "re@@", "a@@", "apt", "c@@", "t", "<unk>"]
					__A             =			dict(zip(A							,range(len(A			)			)			)			)
					__A             =			["#version: 0.2", "a p", "ap t</w>", "r e", "a d", "ad apt</w>", ""]
					__A             =			{"unk_token": "<unk>"}

					__A             =			os.path.join(self.tmpdirname							,VOCAB_FILES_NAMES["vocab_file"]			)
					__A             =			os.path.join(self.tmpdirname							,VOCAB_FILES_NAMES["merges_file"]			)
					with open(self.vocab_file							,"w"							,encoding="utf-8"			) as fp:
									fp.write(json.dumps(A			) + "\n"			)
					with open(self.merges_file							,"w"							,encoding="utf-8"			) as fp:
									fp.write("\n".join(A			)			)






	def     UpperCamelCase_  (	self :			List[str]							,**A :			List[str]			):
					kwargs.update(self.special_tokens_map			)
					return CTRLTokenizer.from_pretrained(self.tmpdirname							,**A			)






	def     UpperCamelCase_  (	self :			Optional[int]							,A :			Tuple			):
					__A             =			"adapt react readapt apt"
					__A             =			"adapt react readapt apt"
					return input_text, output_text







	def     UpperCamelCase_  (	self :			Any			):
					__A             =			CTRLTokenizer(self.vocab_file							,self.merges_file							,**self.special_tokens_map			)
					__A             =			"adapt react readapt apt"
					__A             =			"adapt re@@ a@@ c@@ t re@@ adapt apt".split()
					__A             =			tokenizer.tokenize(A			)
					self.assertListEqual(A							,A			)

					__A             =			tokens + [tokenizer.unk_token]

					__A             =			[0, 1, 2, 4, 5, 1, 0, 3, 6]
					self.assertListEqual(tokenizer.convert_tokens_to_ids(A			)							,A			)
