
"""simple docstring"""

import inspect
import unittest

from transformers import ViTHybridConfig
from transformers.testing_utils import require_accelerate, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch
   from torch import nn

   from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel
   from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image
class      _UpperCAmelCase							:




      def __init__(							self   ,       lowercase_   ,       lowercase_=1_3   ,       lowercase_=6_4   ,       lowercase_=2   ,       lowercase_=3   ,       lowercase_=True   ,       lowercase_=True   ,       lowercase_=3_2   ,       lowercase_=5   ,       lowercase_=4   ,       lowercase_=3_7   ,       lowercase_="gelu"   ,       lowercase_=0.1   ,       lowercase_=0.1   ,       lowercase_=1_0   ,       lowercase_=0.0_2   ,       lowercase_=[1, 1_6, 4, 4]   ,       lowercase_=None   ,       )						->					Union[str, Any]:
          UpperCAmelCase									=					parent
          UpperCAmelCase									=					batch_size
          UpperCAmelCase									=					image_size
          UpperCAmelCase									=					patch_size
          UpperCAmelCase									=					num_channels
          UpperCAmelCase									=					is_training
          UpperCAmelCase									=					use_labels
          UpperCAmelCase									=					hidden_size
          UpperCAmelCase									=					num_hidden_layers
          UpperCAmelCase									=					num_attention_heads
          UpperCAmelCase									=					intermediate_size
          UpperCAmelCase									=					hidden_act
          UpperCAmelCase									=					hidden_dropout_prob
          UpperCAmelCase									=					attention_probs_dropout_prob
          UpperCAmelCase									=					type_sequence_label_size
          UpperCAmelCase									=					initializer_range
          UpperCAmelCase									=					scope
          UpperCAmelCase									=					backbone_featmap_shape

          # in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
          # the number of patches is based on the feature map of the backbone, which by default uses an output stride
          # of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size
          UpperCAmelCase									=					(self.image_size // 3_2) ** 2
          UpperCAmelCase									=					num_patches + 1




      def     a_      (							self							)						->					List[str]:
          UpperCAmelCase									=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

          UpperCAmelCase									=					None
          if self.use_labels:
              UpperCAmelCase									=					ids_tensor([self.batch_size]   ,       self.type_sequence_label_size							)

          UpperCAmelCase									=					self.get_config()

          return config, pixel_values, labels




      def     a_      (							self							)						->					Any:
          UpperCAmelCase									=					{
              '''global_padding''': '''same''',
              '''layer_type''': '''bottleneck''',
              '''depths''': [3, 4, 9],
              '''out_features''': ['''stage1''', '''stage2''', '''stage3'''],
              '''embedding_dynamic_padding''': True,
              '''hidden_sizes''': [4, 8, 1_6, 3_2],
              '''num_groups''': 2,
          }

          return ViTHybridConfig(
              image_size=self.image_size   ,       patch_size=self.patch_size   ,       num_channels=self.num_channels   ,       hidden_size=self.hidden_size   ,       num_hidden_layers=self.num_hidden_layers   ,       num_attention_heads=self.num_attention_heads   ,       intermediate_size=self.intermediate_size   ,       hidden_act=self.hidden_act   ,       hidden_dropout_prob=self.hidden_dropout_prob   ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,       is_decoder=lowercase_   ,       initializer_range=self.initializer_range   ,       backbone_featmap_shape=self.backbone_featmap_shape   ,       backbone_config=lowercase_   ,       )




      def     a_      (							self   ,       lowercase_   ,       lowercase_   ,       lowercase_							)						->					Union[str, Any]:
          UpperCAmelCase									=					ViTHybridModel(config=lowercase_							)
          model.to(lowercase_							)
          model.eval()
          UpperCAmelCase									=					model(lowercase_							)
          self.parent.assertEqual(result.last_hidden_state.shape   ,       (self.batch_size, self.seq_length, self.hidden_size)							)




      def     a_      (							self   ,       lowercase_   ,       lowercase_   ,       lowercase_							)						->					Tuple:
          UpperCAmelCase									=					self.type_sequence_label_size
          UpperCAmelCase									=					ViTHybridForImageClassification(lowercase_							)
          model.to(lowercase_							)
          model.eval()
          UpperCAmelCase									=					model(lowercase_   ,       labels=lowercase_							)
          self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.type_sequence_label_size)							)




      def     a_      (							self							)						->					Union[str, Any]:
          UpperCAmelCase									=					self.prepare_config_and_inputs()
          UpperCAmelCase									=					config_and_inputs
          UpperCAmelCase									=					{'''pixel_values''': pixel_values}
          return config, inputs_dict

@require_torch
class      _UpperCAmelCase							(		UpperCamelCase_     ,			UpperCamelCase_     ,			unittest.TestCase							):
      __SCREAMING_SNAKE_CASE   :							List[Any]							      =	(ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
      __SCREAMING_SNAKE_CASE   :							List[Any]							      =	(
          {"feature-extraction": ViTHybridModel, "image-classification": ViTHybridForImageClassification}
          if is_torch_available()
          else {}
      )
      __SCREAMING_SNAKE_CASE   :							Dict							      =	False
      __SCREAMING_SNAKE_CASE   :							List[str]							      =	False
      __SCREAMING_SNAKE_CASE   :							Any							      =	False




      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					ViTHybridModelTester(self							)
          UpperCAmelCase									=					ConfigTester(self   ,       config_class=lowercase_   ,       has_text_modality=lowercase_   ,       hidden_size=3_7							)




      def     a_      (							self							)						->					Any:
          self.config_tester.run_common_tests()




      @unittest.skip(reason='ViT does not use inputs_embeds'							)
      def     a_      (							self							)						->					List[str]:
          pass




      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              UpperCAmelCase									=					model_class(lowercase_							)
              self.assertIsInstance(model.get_input_embeddings()   ,       (nn.Module)							)
              UpperCAmelCase									=					model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(lowercase_   ,       nn.Linear							)							)




      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs_for_common()

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

              UpperCAmelCase									=					['''pixel_values''']
              self.assertListEqual(arg_names[:1]   ,       lowercase_							)




      def     a_      (							self							)						->					List[str]:
          UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase_							)




      def     a_      (							self							)						->					int:
          UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowercase_							)




      def     a_      (							self							)						->					Union[str, Any]:
          UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs_for_common()

          UpperCAmelCase									=					_config_zero_init(lowercase_							)
          for model_class in self.all_model_classes:
              UpperCAmelCase									=					model_class(config=lowercase_							)
              # Skip the check for the backbone
              for name, module in model.named_modules():
                  if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
                      UpperCAmelCase									=					[F"{name}.{key}" for key in module.state_dict().keys()]
                      break

              for name, param in model.named_parameters():
                  if param.requires_grad:
                      if name in backbone_params:
                          continue
                      self.assertIn(
                          ((param.data.mean() * 1E9).round() / 1E9).item()   ,       [0.0, 1.0]   ,       msg=F"Parameter {name} of model {model_class} seems not properly initialized"   ,       )




      @slow
      def     a_      (							self							)						->					Tuple:
          for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCAmelCase									=					ViTHybridModel.from_pretrained(lowercase_							)
              self.assertIsNotNone(lowercase_							)




def     lowercase__						(					) ->      int:






    """simple docstring"""




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







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




      @cached_property
      def     a_      (							self							)						->					Optional[int]:
          return (
              ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)
              if is_vision_available()
              else None
          )




      @slow
      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(
              lowercase_							)

          UpperCAmelCase									=					self.default_image_processor
          UpperCAmelCase									=					prepare_img()
          UpperCAmelCase									=					image_processor(images=lowercase_   ,       return_tensors='pt'							).to(lowercase_							)

          # forward pass
          with torch.no_grad():
              UpperCAmelCase									=					model(**lowercase_							)

          # verify the logits
          UpperCAmelCase									=					torch.Size((1, 1_0_0_0)							)
          self.assertEqual(outputs.logits.shape   ,       lowercase_							)

          UpperCAmelCase									=					torch.tensor([-1.9_0_9_0, -0.4_9_9_3, -0.2_3_8_9]							).to(lowercase_							)

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




      @slow
      @require_accelerate
      def     a_      (							self							)						->					List[Any]:
          UpperCAmelCase									=					ViTHybridImageProcessor.from_pretrained('google/vit-hybrid-base-bit-384'							)
          UpperCAmelCase									=					ViTHybridForImageClassification.from_pretrained('google/vit-hybrid-base-bit-384'   ,       device_map='auto'							)

          UpperCAmelCase									=					prepare_img()

          UpperCAmelCase									=					image_processor(images=lowercase_   ,       return_tensors='pt'							)
          UpperCAmelCase									=					model(**lowercase_							)
          UpperCAmelCase									=					outputs.logits
          # model predicts one of the 1000 ImageNet classes
          UpperCAmelCase									=					logits.argmax(-1							).item()

          self.assertTrue(model.config.idalabel[predicted_class_idx]   ,       'tabby, tabby cat'							)





"""simple docstring"""

import inspect
import unittest

from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
   import jax
   import jax.numpy as jnp

   from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel

if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor
class      _UpperCAmelCase							(		unittest.TestCase							):




      def __init__(							self   ,       lowercase_   ,       lowercase_=3   ,       lowercase_=3_2   ,       lowercase_=3   ,       lowercase_=1_0   ,       lowercase_=[1_0, 2_0, 3_0, 4_0]   ,       lowercase_=[1, 1, 2, 1]   ,       lowercase_=True   ,       lowercase_=True   ,       lowercase_="relu"   ,       lowercase_=3   ,       lowercase_=None   ,       )						->					str:
          UpperCAmelCase									=					parent
          UpperCAmelCase									=					batch_size
          UpperCAmelCase									=					image_size
          UpperCAmelCase									=					num_channels
          UpperCAmelCase									=					embeddings_size
          UpperCAmelCase									=					hidden_sizes
          UpperCAmelCase									=					depths
          UpperCAmelCase									=					is_training
          UpperCAmelCase									=					use_labels
          UpperCAmelCase									=					hidden_act
          UpperCAmelCase									=					num_labels
          UpperCAmelCase									=					scope
          UpperCAmelCase									=					len(lowercase_							)




      def     a_      (							self							)						->					Optional[int]:
          UpperCAmelCase									=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

          UpperCAmelCase									=					self.get_config()

          return config, pixel_values




      def     a_      (							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   ,       image_size=self.image_size   ,       )




      def     a_      (							self   ,       lowercase_   ,       lowercase_							)						->					List[Any]:
          UpperCAmelCase									=					FlaxRegNetModel(config=lowercase_							)
          UpperCAmelCase									=					model(lowercase_							)

          # Output shape (b, c, h, w)
          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     a_      (							self   ,       lowercase_   ,       lowercase_							)						->					Union[str, Any]:
          UpperCAmelCase									=					self.num_labels
          UpperCAmelCase									=					FlaxRegNetForImageClassification(config=lowercase_							)
          UpperCAmelCase									=					model(lowercase_							)
          self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.num_labels)							)




      def     a_      (							self							)						->					List[Any]:
          UpperCAmelCase									=					self.prepare_config_and_inputs()
          UpperCAmelCase			,							UpperCAmelCase									=					config_and_inputs
          UpperCAmelCase									=					{'pixel_values': pixel_values}
          return config, inputs_dict

@require_flax
class      _UpperCAmelCase							(		SCREAMING_SNAKE_CASE_     ,			unittest.TestCase							):
      __SCREAMING_SNAKE_CASE   :							Tuple							      =	(FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

      __SCREAMING_SNAKE_CASE   :							List[Any]							      =	False
      __SCREAMING_SNAKE_CASE   :							Optional[int]							      =	False
      __SCREAMING_SNAKE_CASE   :							Tuple							      =	False




      def     a_      (							self							)						->					None:
          UpperCAmelCase									=					FlaxRegNetModelTester(self							)
          UpperCAmelCase									=					ConfigTester(self   ,       config_class=lowercase_   ,       has_text_modality=lowercase_							)




      def     a_      (							self							)						->					List[Any]:
          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							)						->					Optional[Any]:
          return




      def     a_      (							self							)						->					Any:
          UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase_							)




      def     a_      (							self							)						->					List[str]:
          UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowercase_							)




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




      @unittest.skip(reason='RegNet does not support input and output embeddings'							)
      def     a_      (							self							)						->					Optional[int]:
          pass




      def     a_      (							self							)						->					Dict:
          UpperCAmelCase			,							UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs_for_common()

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

              UpperCAmelCase									=					['pixel_values']
              self.assertListEqual(arg_names[:1]   ,       lowercase_							)




      def     a_      (							self							)						->					int:
          def check_hidden_states_output(lowercase_   ,       lowercase_   ,       lowercase_							):
              UpperCAmelCase									=					model_class(lowercase_							)

              UpperCAmelCase									=					model(**self._prepare_for_class(lowercase_   ,       lowercase_							)							)

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

              UpperCAmelCase									=					self.model_tester.num_stages
              self.assertEqual(len(lowercase_							)   ,       expected_num_stages + 1							)

          UpperCAmelCase			,							UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              UpperCAmelCase									=					True
              check_hidden_states_output(lowercase_   ,       lowercase_   ,       lowercase_							)

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

              check_hidden_states_output(lowercase_   ,       lowercase_   ,       lowercase_							)




      def     a_      (							self							)						->					List[Any]:
          UpperCAmelCase			,							UpperCAmelCase									=					self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              with self.subTest(model_class.__name__							):
                  UpperCAmelCase									=					self._prepare_for_class(lowercase_   ,       lowercase_							)
                  UpperCAmelCase									=					model_class(lowercase_							)

                  @jax.jit
                  def model_jitted(lowercase_   ,       **lowercase_							):
                      return model(pixel_values=lowercase_   ,       **lowercase_							)

                  with self.subTest('JIT Enabled'							):
                      UpperCAmelCase									=					model_jitted(**lowercase_							).to_tuple()

                  with self.subTest('JIT Disabled'							):
                      with jax.disable_jit():
                          UpperCAmelCase									=					model_jitted(**lowercase_							).to_tuple()

                  self.assertEqual(len(lowercase_							)   ,       len(lowercase_							)							)
                  for jitted_output, output in zip(lowercase_   ,       lowercase_							):
                      self.assertEqual(jitted_output.shape   ,       output.shape							)




def     lowercase__						(					) ->      Tuple:






    """simple docstring"""




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







@require_flax
class      _UpperCAmelCase							(		unittest.TestCase							):




      @cached_property
      def     a_      (							self							)						->					List[str]:
          return AutoImageProcessor.from_pretrained('facebook/regnet-y-040'							) if is_vision_available() else None




      @slow
      def     a_      (							self							)						->					Union[str, Any]:
          UpperCAmelCase									=					FlaxRegNetForImageClassification.from_pretrained('facebook/regnet-y-040'							)

          UpperCAmelCase									=					self.default_image_processor
          UpperCAmelCase									=					prepare_img()
          UpperCAmelCase									=					image_processor(images=lowercase_   ,       return_tensors='np'							)

          UpperCAmelCase									=					model(**lowercase_							)

          # verify the logits
          UpperCAmelCase									=					(1, 1_0_0_0)
          self.assertEqual(outputs.logits.shape   ,       lowercase_							)

          UpperCAmelCase									=					jnp.array([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]							)

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



