



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



     def __init__(    self			,				UpperCamelCase			,				UpperCamelCase=3			,				UpperCamelCase=32			,				UpperCamelCase=3			,				UpperCamelCase=10			,				UpperCamelCase=[10, 20, 30, 40]			,				UpperCamelCase=[1, 1, 2, 1]			,				UpperCamelCase=True			,				UpperCamelCase=True			,				UpperCamelCase="relu"			,				UpperCamelCase=3			,				UpperCamelCase=None			,				)     ->			Optional[Any]:
      __lowerCAmelCase												=  parent
      __lowerCAmelCase												=  batch_size
      __lowerCAmelCase												=  image_size
      __lowerCAmelCase												=  num_channels
      __lowerCAmelCase												=  embeddings_size
      __lowerCAmelCase												=  hidden_sizes
      __lowerCAmelCase												=  depths
      __lowerCAmelCase												=  is_training
      __lowerCAmelCase												=  use_labels
      __lowerCAmelCase												=  hidden_act
      __lowerCAmelCase												=  num_labels
      __lowerCAmelCase												=  scope
      __lowerCAmelCase												=  len(lowerCAmelCase_     )



     def        UpperCAmelCase_ (    self     )     ->			Tuple:
      __lowerCAmelCase												=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

      __lowerCAmelCase												=  self.get_config()

      return config, pixel_values, labels



     def        UpperCAmelCase_ (    self     )     ->			Union[str, 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			,				)



     def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Optional[Any]:
      __lowerCAmelCase												=  RegNetModel(config=lowerCAmelCase_     )
      model.to(lowerCAmelCase_     )
      model.eval()
      __lowerCAmelCase												=  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 // 32, self.image_size // 32)			,				)



     def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			int:
      __lowerCAmelCase												=  self.num_labels
      __lowerCAmelCase												=  RegNetForImageClassification(lowerCAmelCase_     )
      model.to(lowerCAmelCase_     )
      model.eval()
      __lowerCAmelCase												=  model(lowerCAmelCase_			,				labels=lowerCAmelCase_     )
      self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels)     )



     def        UpperCAmelCase_ (    self     )     ->			Any:
      __lowerCAmelCase												=  self.prepare_config_and_inputs()
      __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase												=  config_and_inputs
      __lowerCAmelCase												=  {"pixel_values": pixel_values}
      return config, inputs_dict






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

     a      :     str        =							False
     a      :     Optional[Any]        =							False
     a      :     Any        =							False
     a      :     Tuple        =							False



     def        UpperCAmelCase_ (    self     )     ->			Any:
      __lowerCAmelCase												=  RegNetModelTester(self     )
      __lowerCAmelCase												=  ConfigTester(self			,				config_class=lowerCAmelCase_			,				has_text_modality=lowerCAmelCase_     )



     def        UpperCAmelCase_ (    self     )     ->			Optional[int]:
      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        UpperCAmelCase_ (    self     )     ->			Dict:
      return



     @unittest.skip(reason="RegNet does not use inputs_embeds"     )
     def        UpperCAmelCase_ (    self     )     ->			Optional[Any]:
      pass



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



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

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

       __lowerCAmelCase												=  ["pixel_values"]
       self.assertListEqual(arg_names[:1]			,				lowerCAmelCase_     )



     def        UpperCAmelCase_ (    self     )     ->			Union[str, Any]:
      __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase_     )



     def        UpperCAmelCase_ (    self     )     ->			Optional[int]:
      __lowerCAmelCase							,       __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __lowerCAmelCase												=  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        UpperCAmelCase_ (    self     )     ->			List[Any]:
      def check_hidden_states_output(UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     ):
       __lowerCAmelCase												=  model_class(lowerCAmelCase_     )
       model.to(lowerCAmelCase_     )
       model.eval()

       with torch.no_grad():
        __lowerCAmelCase												=  model(**self._prepare_for_class(lowerCAmelCase_			,				lowerCAmelCase_     )     )

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

       __lowerCAmelCase												=  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]			,				)

      __lowerCAmelCase							,       __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs_for_common()
      __lowerCAmelCase												=  ["basic", "bottleneck"]
      for model_class in self.all_model_classes:
       for layer_type in layers_type:
        __lowerCAmelCase												=  layer_type
        __lowerCAmelCase												=  True
        check_hidden_states_output(lowerCAmelCase_			,				lowerCAmelCase_			,				lowerCAmelCase_     )

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

        check_hidden_states_output(lowerCAmelCase_			,				lowerCAmelCase_			,				lowerCAmelCase_     )



     def        UpperCAmelCase_ (    self     )     ->			Tuple:
      __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_     )



     @slow
     def        UpperCAmelCase_ (    self     )     ->			Any:
      for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __lowerCAmelCase												=  RegNetModel.from_pretrained(lowerCAmelCase_     )
       self.assertIsNotNone(lowerCAmelCase_     )



def   __lowerCAmelCase					(							):






 '''simple docstring'''




 __lowerCAmelCase												=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
 return image






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



     @cached_property
     def        UpperCAmelCase_ (    self     )     ->			Dict:
      return (
          AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )
          if is_vision_available()
          else None
      )



     @slow
     def        UpperCAmelCase_ (    self     )     ->			Union[str, Any]:
      __lowerCAmelCase												=  RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     ).to(lowerCAmelCase_     )

      __lowerCAmelCase												=  self.default_image_processor
      __lowerCAmelCase												=  prepare_img()
      __lowerCAmelCase												=  image_processor(images=lowerCAmelCase_			,				return_tensors="pt"     ).to(lowerCAmelCase_     )

      # forward pass
      with torch.no_grad():
       __lowerCAmelCase												=  model(**lowerCAmelCase_     )

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

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

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




'''simple docstring'''



import os
import sys
import unittest


lowerCAmelCase	:		str				=   os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import get_test_info  # noqa: E402
from get_test_info import (  # noqa: E402
    get_model_to_test_mapping,
    get_model_to_tester_mapping,
    get_test_to_tester_mapping,
)


lowerCAmelCase	:		Tuple				=   os.path.join('''tests''', '''models''', '''bert''', '''test_modeling_bert.py''')
lowerCAmelCase	:		Tuple				=   os.path.join('''tests''', '''models''', '''blip''', '''test_modeling_blip.py''')






class 					UpperCAmelCase__	(		unittest.TestCase ):



					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase												=  get_test_to_tester_mapping(UpperCamelCase     )
						__lowerCAmelCase												=  get_test_to_tester_mapping(UpperCamelCase     )

						__lowerCAmelCase												=  {"BertModelTest": "BertModelTester"}

						__lowerCAmelCase												=  {
						    "BlipModelTest": "BlipModelTester",
						    "BlipTextImageModelTest": "BlipTextImageModelsModelTester",
						    "BlipTextModelTest": "BlipTextModelTester",
						    "BlipTextRetrievalModelTest": "BlipTextRetrievalModelTester",
						    "BlipVQAModelTest": "BlipVQAModelTester",
						    "BlipVisionModelTest": "BlipVisionModelTester",
						}

						self.assertEqual(get_test_info.to_json(UpperCamelCase     )			,				UpperCamelCase     )
						self.assertEqual(get_test_info.to_json(UpperCamelCase     )			,				UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			List[Any]:
						__lowerCAmelCase												=  get_model_to_test_mapping(UpperCamelCase     )
						__lowerCAmelCase												=  get_model_to_test_mapping(UpperCamelCase     )

						__lowerCAmelCase												=  {
						    "BertForMaskedLM": ["BertModelTest"],
						    "BertForMultipleChoice": ["BertModelTest"],
						    "BertForNextSentencePrediction": ["BertModelTest"],
						    "BertForPreTraining": ["BertModelTest"],
						    "BertForQuestionAnswering": ["BertModelTest"],
						    "BertForSequenceClassification": ["BertModelTest"],
						    "BertForTokenClassification": ["BertModelTest"],
						    "BertLMHeadModel": ["BertModelTest"],
						    "BertModel": ["BertModelTest"],
						}

						__lowerCAmelCase												=  {
						    "BlipForConditionalGeneration": ["BlipTextImageModelTest"],
						    "BlipForImageTextRetrieval": ["BlipTextRetrievalModelTest"],
						    "BlipForQuestionAnswering": ["BlipVQAModelTest"],
						    "BlipModel": ["BlipModelTest"],
						    "BlipTextModel": ["BlipTextModelTest"],
						    "BlipVisionModel": ["BlipVisionModelTest"],
						}

						self.assertEqual(get_test_info.to_json(UpperCamelCase     )			,				UpperCamelCase     )
						self.assertEqual(get_test_info.to_json(UpperCamelCase     )			,				UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase												=  get_model_to_tester_mapping(UpperCamelCase     )
						__lowerCAmelCase												=  get_model_to_tester_mapping(UpperCamelCase     )

						__lowerCAmelCase												=  {
						    "BertForMaskedLM": ["BertModelTester"],
						    "BertForMultipleChoice": ["BertModelTester"],
						    "BertForNextSentencePrediction": ["BertModelTester"],
						    "BertForPreTraining": ["BertModelTester"],
						    "BertForQuestionAnswering": ["BertModelTester"],
						    "BertForSequenceClassification": ["BertModelTester"],
						    "BertForTokenClassification": ["BertModelTester"],
						    "BertLMHeadModel": ["BertModelTester"],
						    "BertModel": ["BertModelTester"],
						}

						__lowerCAmelCase												=  {
						    "BlipForConditionalGeneration": ["BlipTextImageModelsModelTester"],
						    "BlipForImageTextRetrieval": ["BlipTextRetrievalModelTester"],
						    "BlipForQuestionAnswering": ["BlipVQAModelTester"],
						    "BlipModel": ["BlipModelTester"],
						    "BlipTextModel": ["BlipTextModelTester"],
						    "BlipVisionModel": ["BlipVisionModelTester"],
						}

						self.assertEqual(get_test_info.to_json(UpperCamelCase     )			,				UpperCamelCase     )
						self.assertEqual(get_test_info.to_json(UpperCamelCase     )			,				UpperCamelCase     )