


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




 def __init__(		self ,  _lowerCamelCase ,  _lowerCamelCase=3 ,  _lowerCamelCase=32 ,  _lowerCamelCase=3 ,  _lowerCamelCase=10 ,  _lowerCamelCase=[10, 20, 30, 40] ,  _lowerCamelCase=[1, 1, 2, 1] ,  _lowerCamelCase=True ,  _lowerCamelCase=True ,  _lowerCamelCase="relu" ,  _lowerCamelCase=3 ,  _lowerCamelCase=None ,  ):
       a						:Optional[int]										=	parent
       a						:int										=	batch_size
       a						:Tuple										=	image_size
       a						:Union[str, Any]										=	num_channels
       a						:Dict										=	embeddings_size
       a						:Tuple										=	hidden_sizes
       a						:str										=	depths
       a						:List[str]										=	is_training
       a						:Optional[Any]										=	use_labels
       a						:Optional[int]										=	hidden_act
       a						:Any										=	num_labels
       a						:Optional[Any]										=	scope
       a						:List[Any]										=	len(UpperCamelCase__   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Any										=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

       a						:List[Any]										=	None
       if self.use_labels:
             a						:Optional[int]										=	ids_tensor([self.batch_size] ,  self.num_labels   )

       a						:List[str]										=	self.get_config()

       return config, pixel_values, labels




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       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 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:int										=	RegNetModel(config=UpperCamelCase__   )
       model.to(UpperCamelCase__   )
       model.eval()
       a						:Optional[Any]										=	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 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:Optional[int]										=	self.num_labels
       a						:int										=	RegNetForImageClassification(UpperCamelCase__   )
       model.to(UpperCamelCase__   )
       model.eval()
       a						:int										=	model(UpperCamelCase__ ,  labels=UpperCamelCase__   )
       self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:List[Any]										=	self.prepare_config_and_inputs()
       a						:str										=	config_and_inputs
       a						:Optional[int]										=	{'''pixel_values''': pixel_values}
       return config, inputs_dict







@require_torch
class 		_snake_case  (				__SCREAMING_SNAKE_CASE						,   __SCREAMING_SNAKE_CASE						,   unittest.TestCase							):
 SCREAMING_SNAKE_CASE__				=	(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
 SCREAMING_SNAKE_CASE__				=	(
     {'feature-extraction': RegNetModel, 'image-classification': RegNetForImageClassification}
     if is_torch_available()
     else {}
 )

 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Tuple										=	RegNetModelTester(self   )
       a						:Union[str, Any]										=	ConfigTester(self ,  config_class=UpperCamelCase__ ,  has_text_modality=UpperCamelCase__   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       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 	SCREAMING_SNAKE_CASE__    (		self   ):
       return




 @unittest.skip(reason='''RegNet does not use inputs_embeds'''   )
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       pass




 @unittest.skip(reason='''RegNet does not support input and output embeddings'''   )
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       pass




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Dict										=	self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             a						:Any										=	model_class(UpperCamelCase__   )
             a						:Any										=	inspect.signature(model.forward   )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             a						:Union[str, Any]										=	[*signature.parameters.keys()]

             a						:List[str]										=	['''pixel_values''']
             self.assertListEqual(arg_names[:1] ,  UpperCamelCase__   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCamelCase__   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:List[Any]										=	self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             a						:Union[str, Any]										=	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 	SCREAMING_SNAKE_CASE__    (		self   ):







       def check_hidden_states_output(_lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
             a						:Tuple										=	model_class(UpperCamelCase__   )
             model.to(UpperCamelCase__   )
             model.eval()

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

             a						:Optional[Any]										=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

             a						:Dict										=	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						:Optional[Any]										=	self.model_tester.prepare_config_and_inputs_for_common()
       a						:List[Any]										=	['''basic''', '''bottleneck''']
       for model_class in self.all_model_classes:
             for layer_type in layers_type:
                   a						:Any										=	layer_type
                   a						:List[str]										=	True
                   check_hidden_states_output(UpperCamelCase__ ,  UpperCamelCase__ ,  UpperCamelCase__   )

                   # check that output_hidden_states also work using config
                   del inputs_dict["output_hidden_states"]
                   a						:List[Any]										=	True

                   check_hidden_states_output(UpperCamelCase__ ,  UpperCamelCase__ ,  UpperCamelCase__   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Tuple										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__   )




 @slow
 def 	SCREAMING_SNAKE_CASE__    (		self   ):







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







def     __lowerCamelCase						(			):




      """simple docstring"""





      a						:Union[str, Any]										=	Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
      return image







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




 @cached_property
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       return (
           AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
           if is_vision_available()
           else None
       )




 @slow
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(UpperCamelCase__   )

       a						:int										=	self.default_image_processor
       a						:Tuple										=	prepare_img()
       a						:Dict										=	image_processor(images=UpperCamelCase__ ,  return_tensors='''pt'''   ).to(UpperCamelCase__   )

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

       # verify the logits
       a						:List[Any]										=	torch.Size((1, 1000)   )
       self.assertEqual(outputs.logits.shape ,  UpperCamelCase__   )

       a						:Optional[Any]										=	torch.tensor([-0.4180, -1.5051, -3.4836]   ).to(UpperCamelCase__   )

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









def     __lowerCamelCase						(			UpperCAmelCase_						:		int						):




      """simple docstring"""





      if not isinstance(UpperCAmelCase_			,  UpperCAmelCase_						):
            raise TypeError('''Input value must be an \'int\' type'''						)

      a						:Optional[int]										=	0
      while number:
            position += 1
            number >>= 1

      return position


if __name__ == "__main__":
     import doctest

     doctest.testmod()





