

'''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 							A__    :





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =parent
       _SCREAMING_SNAKE_CASE							    =batch_size
       _SCREAMING_SNAKE_CASE							    =image_size
       _SCREAMING_SNAKE_CASE							    =num_channels
       _SCREAMING_SNAKE_CASE							    =embeddings_size
       _SCREAMING_SNAKE_CASE							    =hidden_sizes
       _SCREAMING_SNAKE_CASE							    =depths
       _SCREAMING_SNAKE_CASE							    =is_training
       _SCREAMING_SNAKE_CASE							    =use_labels
       _SCREAMING_SNAKE_CASE							    =hidden_act
       _SCREAMING_SNAKE_CASE							    =num_labels
       _SCREAMING_SNAKE_CASE							    =scope
       _SCREAMING_SNAKE_CASE							    =len(_a )





  def 						A  (		self      :	Any )	->    int:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

       _SCREAMING_SNAKE_CASE							    =self.get_config()

       return config, pixel_values, labels





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





       '''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 						A  (		self      :	Optional[Any]							,					_a      :	str							,					_a      :	List[str]							,					_a      :	List[str] )	->    List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =RegNetModel(config=_a )
       model.to(_a )
       model.eval()
       _SCREAMING_SNAKE_CASE							    =model(_a )
       # 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 						A  (		self      :	int							,					_a      :	List[Any]							,					_a      :	Any							,					_a      :	Optional[Any] )	->    List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.num_labels
       _SCREAMING_SNAKE_CASE							    =RegNetForImageClassification(_a )
       model.to(_a )
       model.eval()
       _SCREAMING_SNAKE_CASE							    =model(_a							,					labels=_a )
       self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_labels) )





  def 						A  (		self      :	Optional[Any] )	->    Dict:





       '''simple docstring'''






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







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

  A__		 =				False
  A__		 =				False
  A__		 =				False
  A__		 =				False





  def 						A  (		self      :	Dict )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =RegNetModelTester(self )
       _SCREAMING_SNAKE_CASE							    =ConfigTester(self							,					config_class=_a							,					has_text_modality=_a )





  def 						A  (		self      :	int )	->    Optional[int]:





       '''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 						A  (		self      :	Tuple )	->    Tuple:





       '''simple docstring'''






       return





  @unittest.skip(reason='RegNet does not use inputs_embeds' )
  def 						A  (		self      :	Tuple )	->    List[str]:





       '''simple docstring'''






       pass





  @unittest.skip(reason='RegNet does not support input and output embeddings' )
  def 						A  (		self      :	List[Any] )	->    List[str]:





       '''simple docstring'''






       pass





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs_for_common()

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

            _SCREAMING_SNAKE_CASE							    =['pixel_values']
            self.assertListEqual(arg_names[:1]							,					_a )





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_a )





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            _SCREAMING_SNAKE_CASE							    =model_class(config=_a )
            for name, module in model.named_modules():
                 if isinstance(_a							,					(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 						A  (		self      :	int )	->    List[Any]:





       '''simple docstring'''






       def check_hidden_states_output(_a      :	Optional[int]							,					_a      :	int							,					_a      :	Dict ):
            _SCREAMING_SNAKE_CASE							    =model_class(_a )
            model.to(_a )
            model.eval()

            with torch.no_grad():
                 _SCREAMING_SNAKE_CASE							    =model(**self._prepare_for_class(_a							,					_a ) )

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

            _SCREAMING_SNAKE_CASE							    =self.model_tester.num_stages
            self.assertEqual(len(_a )							,					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]							,					)

       _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs_for_common()
       _SCREAMING_SNAKE_CASE							    =['basic', 'bottleneck']
       for model_class in self.all_model_classes:
            for layer_type in layers_type:
                 _SCREAMING_SNAKE_CASE							    =layer_type
                 _SCREAMING_SNAKE_CASE							    =True
                 check_hidden_states_output(_a							,					_a							,					_a )

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

                 check_hidden_states_output(_a							,					_a							,					_a )





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_a )





  @slow
  def 						A  (		self      :	List[str] )	->    Dict:





       '''simple docstring'''






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


def        _lowerCAmelCase					(						)      ->			int:
     """simple docstring"""




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







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





  @cached_property
  def 						A  (		self      :	Optional[Any] )	->    int:





       '''simple docstring'''






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





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(_a )

       _SCREAMING_SNAKE_CASE							    =self.default_image_processor
       _SCREAMING_SNAKE_CASE							    =prepare_img()
       _SCREAMING_SNAKE_CASE							    =image_processor(images=_a							,					return_tensors='pt' ).to(_a )

       # forward pass
       with torch.no_grad():
            _SCREAMING_SNAKE_CASE							    =model(**_a )

       # verify the logits
       _SCREAMING_SNAKE_CASE							    =torch.Size((1, 1000) )
       self.assertEqual(outputs.logits.shape							,					_a )

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

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



'''simple docstring'''
import copy
import re







class 							A__    :
  A__		 =				'hp'
  A__		 =				{}
  A__		 =				None





  @classmethod
  def 						A  (		cls      :	Optional[Any]							,					_a      :	Optional[Any]							,					_a      :	Any )	->    Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =prefix
       _SCREAMING_SNAKE_CASE							    =defaults
       cls.build_naming_info()





  @staticmethod
  def 						A  (		_a      :	Optional[Any]							,					_a      :	List[Any] )	->    Any:





       '''simple docstring'''






       if len(_a ) == 0:
            return ""
       _SCREAMING_SNAKE_CASE							    =None
       if any(char.isdigit() for char in word ):
            raise Exception(f"Parameters should not contain numbers: '{word}' contains a number" )
       if word in info["short_word"]:
            return info["short_word"][word]
       for prefix_len in range(1							,					len(_a ) + 1 ):
            _SCREAMING_SNAKE_CASE							    =word[:prefix_len]
            if prefix in info["reverse_short_word"]:
                 continue
            else:
                 _SCREAMING_SNAKE_CASE							    =prefix
                 break

       if short_word is None:
            # Paranoid fallback
            def int_to_alphabetic(_a      :	str ):
                 _SCREAMING_SNAKE_CASE							    =''
                 while integer != 0:
                      _SCREAMING_SNAKE_CASE							    =chr(ord('A' ) + integer % 10 ) + s
                      integer //= 10
                 return s

            _SCREAMING_SNAKE_CASE							    =0
            while True:
                 _SCREAMING_SNAKE_CASE							    =word + '#' + int_to_alphabetic(_a )
                 if sword in info["reverse_short_word"]:
                      continue
                 else:
                      _SCREAMING_SNAKE_CASE							    =sword
                      break

       _SCREAMING_SNAKE_CASE							    =short_word
       _SCREAMING_SNAKE_CASE							    =word
       return short_word





  @staticmethod
  def 						A  (		_a      :	Optional[Any]							,					_a      :	int )	->    Optional[int]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =param_name.split('_' )

       _SCREAMING_SNAKE_CASE							    =[TrialShortNamer.shortname_for_word(_a							,					_a ) for word in words]

       # We try to create a separatorless short name, but if there is a collision we have to fallback
       # to a separated short name
       _SCREAMING_SNAKE_CASE							    =['', '_']

       for separator in separators:
            _SCREAMING_SNAKE_CASE							    =separator.join(_a )
            if shortname not in info["reverse_short_param"]:
                 _SCREAMING_SNAKE_CASE							    =shortname
                 _SCREAMING_SNAKE_CASE							    =param_name
                 return shortname

       return param_name





  @staticmethod
  def 						A  (		_a      :	Dict							,					_a      :	int )	->    Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =TrialShortNamer.shortname_for_key(_a							,					_a )
       _SCREAMING_SNAKE_CASE							    =short_name
       _SCREAMING_SNAKE_CASE							    =param_name





  @classmethod
  def 						A  (		cls      :	Optional[int] )	->    Tuple:





       '''simple docstring'''






       if cls.NAMING_INFO is not None:
            return

       _SCREAMING_SNAKE_CASE							    ={
           'short_word': {},
           'reverse_short_word': {},
           'short_param': {},
           'reverse_short_param': {},
       }

       _SCREAMING_SNAKE_CASE							    =list(cls.DEFAULTS.keys() )

       for k in field_keys:
            cls.add_new_param_name(_a							,					_a )

       _SCREAMING_SNAKE_CASE							    =info





  @classmethod
  def 						A  (		cls      :	List[Any]							,					_a      :	int )	->    int:





       '''simple docstring'''






       cls.build_naming_info()
       assert cls.PREFIX is not None
       _SCREAMING_SNAKE_CASE							    =[copy.copy(cls.PREFIX )]

       for k, v in params.items():
            if k not in cls.DEFAULTS:
                 raise Exception(f"You should provide a default value for the param name {k} with value {v}" )
            if v == cls.DEFAULTS[k]:
                 # The default value is not added to the name
                 continue

            _SCREAMING_SNAKE_CASE							    =cls.NAMING_INFO['short_param'][k]

            if isinstance(_a							,					_a ):
                 _SCREAMING_SNAKE_CASE							    =1 if v else 0

            _SCREAMING_SNAKE_CASE							    ='' if isinstance(_a							,					(int, float) ) else '-'
            _SCREAMING_SNAKE_CASE							    =f"{key}{sep}{v}"
            name.append(_a )

       return "_".join(_a )





  @classmethod
  def 						A  (		cls      :	Optional[Any]							,					_a      :	List[Any] )	->    Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =repr[len(cls.PREFIX ) + 1 :]
       if repr == "":
            _SCREAMING_SNAKE_CASE							    =[]
       else:
            _SCREAMING_SNAKE_CASE							    =repr.split('_' )

       _SCREAMING_SNAKE_CASE							    ={}

       for value in values:
            if "-" in value:
                 _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE							    =value.split('-' )
            else:
                 _SCREAMING_SNAKE_CASE							    =re.sub('[0-9.]'							,					''							,					_a )
                 _SCREAMING_SNAKE_CASE							    =float(re.sub('[^0-9.]'							,					''							,					_a ) )

            _SCREAMING_SNAKE_CASE							    =cls.NAMING_INFO['reverse_short_param'][p_k]

            _SCREAMING_SNAKE_CASE							    =p_v

       for k in cls.DEFAULTS:
            if k not in parameters:
                 _SCREAMING_SNAKE_CASE							    =cls.DEFAULTS[k]

       return parameters
