
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     :							Union[str, Any]			,			lowerCAmelCase_     :							int			,			lowerCAmelCase_     :							int=3			,			lowerCAmelCase_     :							Optional[Any]=3_2			,			lowerCAmelCase_     :							int=3			,			lowerCAmelCase_     :							List[Any]=1_0			,			lowerCAmelCase_     :							int=[1_0, 2_0, 3_0, 4_0]			,			lowerCAmelCase_     :							Union[str, Any]=[1, 1, 2, 1]			,			lowerCAmelCase_     :							Union[str, Any]=True			,			lowerCAmelCase_     :							List[Any]=True			,			lowerCAmelCase_     :							List[str]="relu"			,			lowerCAmelCase_     :							Optional[int]=3			,			lowerCAmelCase_     :							int=None			,			):

      """simple docstring"""
      _A:  List[Any]					=       parent
      _A:  Any					=       batch_size
      _A:  Union[str, Any]					=       image_size
      _A:  Union[str, Any]					=       num_channels
      _A:  Union[str, Any]					=       embeddings_size
      _A:  List[Any]					=       hidden_sizes
      _A:  int					=       depths
      _A:  str					=       is_training
      _A:  int					=       use_labels
      _A:  Optional[Any]					=       hidden_act
      _A:  Optional[int]					=       num_labels
      _A:  int					=       scope
      _A:  Union[str, Any]					=       len(lowerCAmelCase_     )


   def  __magic_name__				(					self     :							int     ):

      """simple docstring"""
      _A:  Tuple					=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

      _A:  Optional[Any]					=       self.get_config()

      return config, pixel_values, labels


   def  __magic_name__				(					self     :							List[str]     ):

      """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  __magic_name__				(					self     :							List[str]			,			lowerCAmelCase_     :							Optional[Any]			,			lowerCAmelCase_     :							Tuple			,			lowerCAmelCase_     :							Dict     ):

      """simple docstring"""
      _A:  int					=       RegNetModel(config=lowerCAmelCase_     )
      model.to(lowerCAmelCase_     )
      model.eval()
      _A:  Union[str, Any]					=       model(lowerCAmelCase_     )
      # 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 // 3_2, self.image_size // 3_2)			,			)


   def  __magic_name__				(					self     :							List[Any]			,			lowerCAmelCase_     :							int			,			lowerCAmelCase_     :							int			,			lowerCAmelCase_     :							Optional[Any]     ):

      """simple docstring"""
      _A:  Tuple					=       self.num_labels
      _A:  List[str]					=       RegNetForImageClassification(lowerCAmelCase_     )
      model.to(lowerCAmelCase_     )
      model.eval()
      _A:  Union[str, Any]					=       model(lowerCAmelCase_			,			labels=lowerCAmelCase_     )
      self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.num_labels)     )


   def  __magic_name__				(					self     :							Optional[Any]     ):

      """simple docstring"""
      _A:  Optional[int]					=       self.prepare_config_and_inputs()
      _A			,  _A			,  _A:  Dict					=       config_and_inputs
      _A:  List[Any]					=       {'''pixel_values''': pixel_values}
      return config, inputs_dict






@require_torch
class UpperCAmelCase   (						SCREAMING_SNAKE_CASE__							,							SCREAMING_SNAKE_CASE__							,							unittest.TestCase   ):





   '''simple docstring'''
   __UpperCamelCase		:    Union[str, Any] 				=    (RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
   __UpperCamelCase		:    int 				=    (
       {'''feature-extraction''': RegNetModel, '''image-classification''': RegNetForImageClassification}
       if is_torch_available()
       else {}
   )

   __UpperCamelCase		:    Any 				=    False
   __UpperCamelCase		:    str 				=    False
   __UpperCamelCase		:    Any 				=    False
   __UpperCamelCase		:    List[Any] 				=    False


   def  __magic_name__				(					self     :							Optional[Any]     ):

      """simple docstring"""
      _A:  Optional[Any]					=       RegNetModelTester(self     )
      _A:  List[Any]					=       ConfigTester(self			,			config_class=lowerCAmelCase_			,			has_text_modality=lowerCAmelCase_     )


   def  __magic_name__				(					self     :							List[str]     ):

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

      """simple docstring"""
      return


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

      """simple docstring"""
      pass


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

      """simple docstring"""
      pass


   def  __magic_name__				(					self     :							List[Any]     ):

      """simple docstring"""
      _A			,  _A:  Optional[Any]					=       self.model_tester.prepare_config_and_inputs_for_common()

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

         _A:  Any					=       ['''pixel_values''']
         self.assertListEqual(arg_names[:1]			,			lowerCAmelCase_     )


   def  __magic_name__				(					self     :							Optional[Any]     ):

      """simple docstring"""
      _A:  str					=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase_     )


   def  __magic_name__				(					self     :							Any     ):

      """simple docstring"""
      _A			,  _A:  Optional[Any]					=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _A:  Dict					=       model_class(config=lowerCAmelCase_     )
         for name, module in model.named_modules():
            if isinstance(lowerCAmelCase_			,			(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  __magic_name__				(					self     :							Tuple     ):

      """simple docstring"""
      def check_hidden_states_output(lowerCAmelCase_     :							str			,			lowerCAmelCase_     :							str			,			lowerCAmelCase_     :							Optional[Any]     ):
         _A:  str					=       model_class(lowerCAmelCase_     )
         model.to(lowerCAmelCase_     )
         model.eval()

         with torch.no_grad():
            _A:  List[Any]					=       model(**self._prepare_for_class(lowerCAmelCase_			,			lowerCAmelCase_     )     )

         _A:  Dict					=       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         _A:  Tuple					=       self.model_tester.num_stages
         self.assertEqual(len(lowerCAmelCase_     )			,			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:  Any					=       self.model_tester.prepare_config_and_inputs_for_common()
      _A:  str					=       ['''basic''', '''bottleneck''']
      for model_class in self.all_model_classes:
         for layer_type in layers_type:
            _A:  int					=       layer_type
            _A:  Any					=       True
            check_hidden_states_output(lowerCAmelCase_			,			lowerCAmelCase_			,			lowerCAmelCase_     )

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

            check_hidden_states_output(lowerCAmelCase_			,			lowerCAmelCase_			,			lowerCAmelCase_     )


   def  __magic_name__				(					self     :							str     ):

      """simple docstring"""
      _A:  Union[str, Any]					=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_     )


   @slow
   def  __magic_name__				(					self     :							Dict     ):

      """simple docstring"""
      for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _A:  Any					=       RegNetModel.from_pretrained(lowerCAmelCase_     )
         self.assertIsNotNone(lowerCAmelCase_     )






def   lowerCamelCase__							(					)      ->   Optional[int]:
   _A:  Any					=       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
   return image






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





   '''simple docstring'''


   @cached_property
   def  __magic_name__				(					self     :							Union[str, Any]     ):

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


   @slow
   def  __magic_name__				(					self     :							Dict     ):

      """simple docstring"""
      _A:  List[str]					=       RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     ).to(lowerCAmelCase_     )

      _A:  Any					=       self.default_image_processor
      _A:  Tuple					=       prepare_img()
      _A:  Optional[int]					=       image_processor(images=lowerCAmelCase_			,			return_tensors='''pt'''     ).to(lowerCAmelCase_     )

      # forward pass
      with torch.no_grad():
         _A:  Optional[int]					=       model(**lowerCAmelCase_     )

      # verify the logits
      _A:  Optional[int]					=       torch.Size((1, 1_0_0_0)     )
      self.assertEqual(outputs.logits.shape			,			lowerCAmelCase_     )

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

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





from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase__		:     Dict     			=      logging.get_logger(__name__)

UpperCAmelCase__		:     Union[str, Any]     			=      {
    'caidas/swin2sr-classicalsr-x2-64': (
        'https://huggingface.co/caidas/swin2sr-classicalsr-x2-64/resolve/main/config.json'
    ),
}






class UpperCAmelCase   (						SCREAMING_SNAKE_CASE__   ):





   '''simple docstring'''
   __UpperCamelCase		:    Dict 				=    '''swin2sr'''

   __UpperCamelCase		:    str 				=    {
       '''hidden_size''': '''embed_dim''',
       '''num_attention_heads''': '''num_heads''',
       '''num_hidden_layers''': '''num_layers''',
   }


   def __init__(					self     :							List[str]			,			lowerCAmelCase_     :							int=6_4			,			lowerCAmelCase_     :							Optional[Any]=1			,			lowerCAmelCase_     :							Dict=3			,			lowerCAmelCase_     :							Dict=1_8_0			,			lowerCAmelCase_     :							Union[str, Any]=[6, 6, 6, 6, 6, 6]			,			lowerCAmelCase_     :							Tuple=[6, 6, 6, 6, 6, 6]			,			lowerCAmelCase_     :							int=8			,			lowerCAmelCase_     :							Any=2.0			,			lowerCAmelCase_     :							Union[str, Any]=True			,			lowerCAmelCase_     :							Dict=0.0			,			lowerCAmelCase_     :							Optional[int]=0.0			,			lowerCAmelCase_     :							int=0.1			,			lowerCAmelCase_     :							Any="gelu"			,			lowerCAmelCase_     :							List[str]=False			,			lowerCAmelCase_     :							str=0.02			,			lowerCAmelCase_     :							Optional[Any]=1e-5			,			lowerCAmelCase_     :							int=2			,			lowerCAmelCase_     :							int=1.0			,			lowerCAmelCase_     :							Any="1conv"			,			lowerCAmelCase_     :							List[str]="pixelshuffle"			,			**lowerCAmelCase_     :							str			,			):

      """simple docstring"""
      super().__init__(**lowerCAmelCase_     )

      _A:  List[str]					=       image_size
      _A:  Any					=       patch_size
      _A:  Any					=       num_channels
      _A:  Union[str, Any]					=       embed_dim
      _A:  int					=       depths
      _A:  List[Any]					=       len(lowerCAmelCase_     )
      _A:  int					=       num_heads
      _A:  Any					=       window_size
      _A:  Optional[int]					=       mlp_ratio
      _A:  int					=       qkv_bias
      _A:  List[Any]					=       hidden_dropout_prob
      _A:  List[str]					=       attention_probs_dropout_prob
      _A:  List[Any]					=       drop_path_rate
      _A:  Any					=       hidden_act
      _A:  List[str]					=       use_absolute_embeddings
      _A:  Tuple					=       layer_norm_eps
      _A:  str					=       initializer_range
      _A:  int					=       upscale
      _A:  int					=       img_range
      _A:  Optional[Any]					=       resi_connection
      _A:  int					=       upsampler



