


'''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   ,   __lowercase   ,   __lowercase=3   ,   __lowercase=32   ,   __lowercase=3   ,   __lowercase=10   ,   __lowercase=[10, 20, 30, 40]   ,   __lowercase=[1, 1, 2, 1]   ,   __lowercase=True   ,   __lowercase=True   ,   __lowercase="relu"   ,   __lowercase=3   ,   __lowercase=None   ,   ):

  """simple docstring"""







  __A	:		Optional[Any]	  =      parent
  __A	:		List[Any]	  =      batch_size
  __A	:		str	  =      image_size
  __A	:		Tuple	  =      num_channels
  __A	:		Optional[int]	  =      embeddings_size
  __A	:		Optional[Any]	  =      hidden_sizes
  __A	:		int	  =      depths
  __A	:		Dict	  =      is_training
  __A	:		List[Any]	  =      use_labels
  __A	:		List[str]	  =      hidden_act
  __A	:		List[Any]	  =      num_labels
  __A	:		Any	  =      scope
  __A	:		List[str]	  =      len(__lowercase    )


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Tuple	  =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

  __A	:		List[str]	  =      None
  if self.use_labels:
   __A	:		Dict	  =      ids_tensor([self.batch_size]   ,   self.num_labels    )

  __A	:		Optional[int]	  =      self.get_config()

  return config, pixel_values, labels


 def 			snake_case__ (   self    ):

  """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 			snake_case__ (   self   ,   __lowercase   ,   __lowercase   ,   __lowercase    ):

  """simple docstring"""







  __A	:		str	  =      RegNetModel(config=__lowercase    )
  model.to(__lowercase    )
  model.eval()
  __A	:		List[Any]	  =      model(__lowercase    )
  # 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 			snake_case__ (   self   ,   __lowercase   ,   __lowercase   ,   __lowercase    ):

  """simple docstring"""







  __A	:		Tuple	  =      self.num_labels
  __A	:		List[str]	  =      RegNetForImageClassification(__lowercase    )
  model.to(__lowercase    )
  model.eval()
  __A	:		List[Any]	  =      model(__lowercase   ,   labels=__lowercase    )
  self.parent.assertEqual(result.logits.shape   ,   (self.batch_size, self.num_labels)    )







 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		List[Any]	  =      self.prepare_config_and_inputs()
  __A  ,__A  ,__A	:		List[str]	  =      config_and_inputs
  __A	:		Dict	  =      {'pixel_values': pixel_values}
  return config, inputs_dict


@require_torch
class     _lowerCamelCase       (     snake_case_     ,		snake_case_     ,		unittest.TestCase					):




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

 __lowercase					:		Union[str, Any]     				=    False
 __lowercase					:		List[Any]     				=    False
 __lowercase					:		Any     				=    False
 __lowercase					:		Tuple     				=    False


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		str	  =      RegNetModelTester(self    )
  __A	:		Optional[Any]	  =      ConfigTester(self   ,   config_class=__lowercase   ,   has_text_modality=__lowercase    )


 def 			snake_case__ (   self    ):

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

  """simple docstring"""







  return


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

  """simple docstring"""







  pass


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

  """simple docstring"""







  pass


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A  ,__A	:		str	  =      self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   __A	:		List[Any]	  =      model_class(__lowercase    )
   __A	:		Optional[int]	  =      inspect.signature(model.forward    )
   # signature.parameters is an OrderedDict => so arg_names order is deterministic
   __A	:		Optional[int]	  =      [*signature.parameters.keys()]

   __A	:		int	  =      ['pixel_values']
   self.assertListEqual(arg_names[:1]   ,   __lowercase    )


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Optional[Any]	  =      self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_model(*__lowercase    )


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A  ,__A	:		List[str]	  =      self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   __A	:		Dict	  =      model_class(config=__lowercase    )
   for name, module in model.named_modules():
    if isinstance(__lowercase   ,   (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 			snake_case__ (   self    ):

  """simple docstring"""







  def check_hidden_states_output(__lowercase   ,   __lowercase   ,   __lowercase    ):
   __A	:		Optional[int]	  =      model_class(__lowercase    )
   model.to(__lowercase    )
   model.eval()

   with torch.no_grad():
    __A	:		List[str]	  =      model(**self._prepare_for_class(__lowercase   ,   __lowercase    )    )

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

   __A	:		str	  =      self.model_tester.num_stages
   self.assertEqual(len(__lowercase    )   ,   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	:		Optional[int]	  =      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	:		str	  =      layer_type
    __A	:		List[Any]	  =      True
    check_hidden_states_output(__lowercase   ,   __lowercase   ,   __lowercase    )

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

    check_hidden_states_output(__lowercase   ,   __lowercase   ,   __lowercase    )


 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Tuple	  =      self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_image_classification(*__lowercase    )







 @slow
 def 			snake_case__ (   self    ):

  """simple docstring"""







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


def       _lowercase							(					):
 __A	:		str	  =      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
 return image


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




 '''simple docstring'''


 @cached_property
 def 			snake_case__ (   self    ):

  """simple docstring"""







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







 @slow
 def 			snake_case__ (   self    ):

  """simple docstring"""







  __A	:		Optional[int]	  =      RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(__lowercase    )

  __A	:		Any	  =      self.default_image_processor
  __A	:		Any	  =      prepare_img()
  __A	:		List[str]	  =      image_processor(images=__lowercase   ,   return_tensors='pt'    ).to(__lowercase    )

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

  # verify the logits
  __A	:		Tuple	  =      torch.Size((1, 1_000)    )
  self.assertEqual(outputs.logits.shape   ,   __lowercase    )

  __A	:		Dict	  =      torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]    ).to(__lowercase    )

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










'''simple docstring'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_			:  Optional[int]										=   logging.get_logger(__name__)

UpperCAmelCase_			:  List[str]										=   {
    'google/fnet-base': 'https://huggingface.co/google/fnet-base/resolve/main/config.json',
    'google/fnet-large': 'https://huggingface.co/google/fnet-large/resolve/main/config.json'
    # See all FNet models at https://huggingface.co/models?filter=fnet
}

class     _lowerCamelCase       (     snake_case_					):




 '''simple docstring'''
 __lowercase					:		List[Any]     				=    '''fnet'''


 def __init__(   self   ,   __lowercase=32_000   ,   __lowercase=768   ,   __lowercase=12   ,   __lowercase=3_072   ,   __lowercase="gelu_new"   ,   __lowercase=0.1   ,   __lowercase=512   ,   __lowercase=4   ,   __lowercase=0.0_2   ,   __lowercase=1E-12   ,   __lowercase=False   ,   __lowercase=512   ,   __lowercase=3   ,   __lowercase=1   ,   __lowercase=2   ,   **__lowercase   ,   ):

  """simple docstring"""







  super().__init__(pad_token_id=__lowercase   ,   bos_token_id=__lowercase   ,   eos_token_id=__lowercase   ,   **__lowercase    )

  __A	:		Union[str, Any]	  =      vocab_size
  __A	:		Dict	  =      max_position_embeddings
  __A	:		List[str]	  =      hidden_size
  __A	:		Tuple	  =      num_hidden_layers
  __A	:		Optional[int]	  =      intermediate_size
  __A	:		Dict	  =      hidden_act
  __A	:		List[str]	  =      hidden_dropout_prob
  __A	:		str	  =      initializer_range
  __A	:		Dict	  =      type_vocab_size
  __A	:		int	  =      layer_norm_eps
  __A	:		Tuple	  =      use_tpu_fourier_optimizations
  __A	:		Optional[Any]	  =      tpu_short_seq_length






