






import collections
import inspect
import unittest

from transformers import DinatConfig
from transformers.testing_utils import require_natten, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
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 DinatBackbone, DinatForImageClassification, DinatModel
  from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor


class  __lowercase :







     '''simple docstring'''




     def __init__(			self    :     str	,		UpperCamelCase_    :     Dict	,		UpperCamelCase_    :     Dict=13	,		UpperCamelCase_    :     str=64	,		UpperCamelCase_    :     str=4	,		UpperCamelCase_    :     int=3	,		UpperCamelCase_    :     Any=16	,		UpperCamelCase_    :     str=[1, 2, 1]	,		UpperCamelCase_    :     str=[2, 4, 8]	,		UpperCamelCase_    :     int=3	,		UpperCamelCase_    :     Dict=[[3], [1, 2], [1]]	,		UpperCamelCase_    :     Any=2.0	,		UpperCamelCase_    :     int=True	,		UpperCamelCase_    :     Union[str, Any]=0.0	,		UpperCamelCase_    :     Optional[Any]=0.0	,		UpperCamelCase_    :     Union[str, Any]=0.1	,		UpperCamelCase_    :     str="gelu"	,		UpperCamelCase_    :     Any=True	,		UpperCamelCase_    :     int=0.02	,		UpperCamelCase_    :     Union[str, Any]=1e-5	,		UpperCamelCase_    :     Optional[Any]=True	,		UpperCamelCase_    :     str=None	,		UpperCamelCase_    :     Tuple=True	,		UpperCamelCase_    :     List[Any]=10	,		UpperCamelCase_    :     Optional[Any]=["stage1", "stage2"]	,		UpperCamelCase_    :     Dict=[1, 2]	,		):


         """simple docstring"""



         __A             =		parent
         __A             =		batch_size
         __A             =		image_size
         __A             =		patch_size
         __A             =		num_channels
         __A             =		embed_dim
         __A             =		depths
         __A             =		num_heads
         __A             =		kernel_size
         __A             =		dilations
         __A             =		mlp_ratio
         __A             =		qkv_bias
         __A             =		hidden_dropout_prob
         __A             =		attention_probs_dropout_prob
         __A             =		drop_path_rate
         __A             =		hidden_act
         __A             =		patch_norm
         __A             =		layer_norm_eps
         __A             =		initializer_range
         __A             =		is_training
         __A             =		scope
         __A             =		use_labels
         __A             =		num_labels
         __A             =		out_features
         __A             =		out_indices




     def 						lowerCAmelCase_       (			self    :     str			):


         """simple docstring"""



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

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

         __A             =		self.get_config()

         return config, pixel_values, labels




     def 						lowerCAmelCase_       (			self    :     str			):


         """simple docstring"""



         return DinatConfig(
             num_labels=self.num_labels	,		image_size=self.image_size	,		patch_size=self.patch_size	,		num_channels=self.num_channels	,		embed_dim=self.embed_dim	,		depths=self.depths	,		num_heads=self.num_heads	,		kernel_size=self.kernel_size	,		dilations=self.dilations	,		mlp_ratio=self.mlp_ratio	,		qkv_bias=self.qkv_bias	,		hidden_dropout_prob=self.hidden_dropout_prob	,		attention_probs_dropout_prob=self.attention_probs_dropout_prob	,		drop_path_rate=self.drop_path_rate	,		hidden_act=self.hidden_act	,		patch_norm=self.patch_norm	,		layer_norm_eps=self.layer_norm_eps	,		initializer_range=self.initializer_range	,		out_features=self.out_features	,		out_indices=self.out_indices	,		)




     def 						lowerCAmelCase_       (			self    :     Any	,		UpperCamelCase_    :     Tuple	,		UpperCamelCase_    :     Dict	,		UpperCamelCase_    :     Any			):


         """simple docstring"""



         __A             =		DinatModel(config=UpperCamelCase_			)
         model.to(UpperCamelCase_			)
         model.eval()
         __A             =		model(UpperCamelCase_			)

         __A             =		__A             =		(config.image_size // config.patch_size) // (2 ** (len(config.depths			) - 1))
         __A             =		int(config.embed_dim * 2 ** (len(config.depths			) - 1)			)

         self.parent.assertEqual(
             result.last_hidden_state.shape	,		(self.batch_size, expected_height, expected_width, expected_dim)			)




     def 						lowerCAmelCase_       (			self    :     str	,		UpperCamelCase_    :     str	,		UpperCamelCase_    :     Dict	,		UpperCamelCase_    :     Tuple			):


         """simple docstring"""



         __A             =		DinatForImageClassification(UpperCamelCase_			)
         model.to(UpperCamelCase_			)
         model.eval()
         __A             =		model(UpperCamelCase_	,		labels=UpperCamelCase_			)
         self.parent.assertEqual(result.logits.shape	,		(self.batch_size, self.num_labels)			)

         # test greyscale images
         __A             =		1
         __A             =		DinatForImageClassification(UpperCamelCase_			)
         model.to(UpperCamelCase_			)
         model.eval()

         __A             =		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
         __A             =		model(UpperCamelCase_			)
         self.parent.assertEqual(result.logits.shape	,		(self.batch_size, self.num_labels)			)




     def 						lowerCAmelCase_       (			self    :     str	,		UpperCamelCase_    :     List[Any]	,		UpperCamelCase_    :     str	,		UpperCamelCase_    :     List[str]			):


         """simple docstring"""



         __A             =		DinatBackbone(config=UpperCamelCase_			)
         model.to(UpperCamelCase_			)
         model.eval()
         __A             =		model(UpperCamelCase_			)

         # verify hidden states
         self.parent.assertEqual(len(result.feature_maps			)	,		len(config.out_features			)			)
         self.parent.assertListEqual(list(result.feature_maps[0].shape			)	,		[self.batch_size, model.channels[0], 16, 16]			)

         # verify channels
         self.parent.assertEqual(len(model.channels			)	,		len(config.out_features			)			)

         # verify backbone works with out_features=None
         __A             =		None
         __A             =		DinatBackbone(config=UpperCamelCase_			)
         model.to(UpperCamelCase_			)
         model.eval()
         __A             =		model(UpperCamelCase_			)

         # verify feature maps
         self.parent.assertEqual(len(result.feature_maps			)	,		1			)
         self.parent.assertListEqual(list(result.feature_maps[0].shape			)	,		[self.batch_size, model.channels[-1], 4, 4]			)

         # verify channels
         self.parent.assertEqual(len(model.channels			)	,		1			)





     def 						lowerCAmelCase_       (			self    :     Any			):


         """simple docstring"""



         __A             =		self.prepare_config_and_inputs()
         __A      ,		__A      ,		__A             =		config_and_inputs
         __A             =		{"""pixel_values""": pixel_values}
         return config, inputs_dict


@require_natten
@require_torch
class  __lowercase (		lowercase_     , lowercase_     , unittest.TestCase					):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE				  =			(
         (
             DinatModel,
             DinatForImageClassification,
             DinatBackbone,
         )
         if is_torch_available()
         else ()
     )
     SCREAMING_SNAKE_CASE				  =			(
         {"feature-extraction": DinatModel, "image-classification": DinatForImageClassification}
         if is_torch_available()
         else {}
     )
     SCREAMING_SNAKE_CASE				  =			False

     SCREAMING_SNAKE_CASE				  =			False
     SCREAMING_SNAKE_CASE				  =			False
     SCREAMING_SNAKE_CASE				  =			False
     SCREAMING_SNAKE_CASE				  =			False




     def 						lowerCAmelCase_       (			self    :     List[Any]			):


         """simple docstring"""



         __A             =		DinatModelTester(self			)
         __A             =		ConfigTester(self	,		config_class=UpperCamelCase_	,		embed_dim=37			)




     def 						lowerCAmelCase_       (			self    :     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 						lowerCAmelCase_       (			self    :     Tuple			):


         """simple docstring"""



         return




     def 						lowerCAmelCase_       (			self    :     Dict			):


         """simple docstring"""



         __A             =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase_			)




     def 						lowerCAmelCase_       (			self    :     List[str]			):


         """simple docstring"""



         __A             =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_			)




     def 						lowerCAmelCase_       (			self    :     List[str]			):


         """simple docstring"""



         __A             =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*UpperCamelCase_			)




     @unittest.skip(reason="""Dinat does not use inputs_embeds"""			)
     def 						lowerCAmelCase_       (			self    :     Dict			):


         """simple docstring"""



         pass




     @unittest.skip(reason="""Dinat does not use feedforward chunking"""			)
     def 						lowerCAmelCase_       (			self    :     Any			):


         """simple docstring"""



         pass




     def 						lowerCAmelCase_       (			self    :     Tuple			):


         """simple docstring"""



         __A      ,		__A             =		self.model_tester.prepare_config_and_inputs_for_common()

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




     def 						lowerCAmelCase_       (			self    :     Union[str, Any]			):


         """simple docstring"""



         __A      ,		__A             =		self.model_tester.prepare_config_and_inputs_for_common()

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

             __A             =		["""pixel_values"""]
             self.assertListEqual(arg_names[:1]	,		UpperCamelCase_			)




     def 						lowerCAmelCase_       (			self    :     Union[str, Any]			):


         """simple docstring"""



         self.skipTest("""Dinat's attention operation is handled entirely by NATTEN."""			)




     def 						lowerCAmelCase_       (			self    :     List[str]	,		UpperCamelCase_    :     Tuple	,		UpperCamelCase_    :     List[Any]	,		UpperCamelCase_    :     Tuple	,		UpperCamelCase_    :     Dict			):


         """simple docstring"""



         __A             =		model_class(UpperCamelCase_			)
         model.to(UpperCamelCase_			)
         model.eval()

         with torch.no_grad():
             __A             =		model(**self._prepare_for_class(UpperCamelCase_	,		UpperCamelCase_			)			)

         __A             =		outputs.hidden_states

         __A             =		getattr(
             self.model_tester	,		"""expected_num_hidden_layers"""	,		len(self.model_tester.depths			) + 1			)
         self.assertEqual(len(UpperCamelCase_			)	,		UpperCamelCase_			)

         # Dinat has a different seq_length
         __A             =		(
             config.patch_size
             if isinstance(config.patch_size	,		collections.abc.Iterable			)
             else (config.patch_size, config.patch_size)
         )

         __A             =		image_size[0] // patch_size[0]
         __A             =		image_size[1] // patch_size[1]

         self.assertListEqual(
             list(hidden_states[0].shape[-3:]			)	,		[height, width, self.model_tester.embed_dim]	,		)

         if model_class.__name__ != "DinatBackbone":
             __A             =		outputs.reshaped_hidden_states
             self.assertEqual(len(UpperCamelCase_			)	,		UpperCamelCase_			)

             __A      ,		__A      ,		__A      ,		__A             =		reshaped_hidden_states[0].shape
             __A             =		(
                 reshaped_hidden_states[0].view(UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_			).permute(0	,		2	,		3	,		1			)
             )
             self.assertListEqual(
                 list(reshaped_hidden_states.shape[-3:]			)	,		[height, width, self.model_tester.embed_dim]	,		)




     def 						lowerCAmelCase_       (			self    :     Optional[Any]			):


         """simple docstring"""



         __A      ,		__A             =		self.model_tester.prepare_config_and_inputs_for_common()

         __A             =		(
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size	,		collections.abc.Iterable			)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )

         for model_class in self.all_model_classes:
             __A             =		True
             self.check_hidden_states_output(UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_			)

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

             self.check_hidden_states_output(UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_	,		UpperCamelCase_			)




     @slow
     def 						lowerCAmelCase_       (			self    :     Tuple			):


         """simple docstring"""



         for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __A             =		DinatModel.from_pretrained(UpperCamelCase_			)
             self.assertIsNotNone(UpperCamelCase_			)





     def 						lowerCAmelCase_       (			self    :     str			):


         """simple docstring"""



         __A      ,		__A             =		self.model_tester.prepare_config_and_inputs_for_common()

         __A             =		_config_zero_init(UpperCamelCase_			)
         for model_class in self.all_model_classes:
             __A             =		model_class(config=UpperCamelCase_			)
             for name, param in model.named_parameters():
                 if "embeddings" not in name and param.requires_grad:
                     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"	,		)


@require_natten
@require_vision
@require_torch
class  __lowercase (		unittest.TestCase					):







     '''simple docstring'''




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


         """simple docstring"""



         return AutoImageProcessor.from_pretrained("""shi-labs/dinat-mini-in1k-224"""			) if is_vision_available() else None





     @slow
     def 						lowerCAmelCase_       (			self    :     Optional[Any]			):


         """simple docstring"""



         __A             =		DinatForImageClassification.from_pretrained("""shi-labs/dinat-mini-in1k-224"""			).to(UpperCamelCase_			)
         __A             =		self.default_image_processor

         __A             =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
         __A             =		image_processor(images=UpperCamelCase_	,		return_tensors="""pt"""			).to(UpperCamelCase_			)

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

         # verify the logits
         __A             =		torch.Size((1, 1_000)			)
         self.assertEqual(outputs.logits.shape	,		UpperCamelCase_			)
         __A             =		torch.tensor([-0.1545, -0.7667, 0.4642]			).to(UpperCamelCase_			)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]	,		UpperCamelCase_	,		atol=1e-4			)			)


@require_torch
@require_natten
class  __lowercase (		unittest.TestCase     , lowercase_					):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE				  =			(DinatBackbone,) if is_torch_available() else ()
     SCREAMING_SNAKE_CASE				  =			DinatConfig




     def 						lowerCAmelCase_       (			self    :     int			):


         """simple docstring"""



         __A             =		DinatModelTester(self			)












import copy

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


__a :    Tuple								=				logging.get_logger(__name__)


class  __lowercase (		lowercase_					):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE				  =			"hybrid-clip"
     SCREAMING_SNAKE_CASE				  =			True




     def __init__(			self    :     Optional[Any]	,		UpperCamelCase_    :     Optional[Any]=512	,		**UpperCamelCase_    :     List[Any]			):


         """simple docstring"""



         super().__init__(**UpperCamelCase_			)

         if "text_config" not in kwargs:
             raise ValueError("""`text_config` can not be `None`."""			)

         if "vision_config" not in kwargs:
             raise ValueError("""`vision_config` can not be `None`."""			)

         __A             =		kwargs.pop("""text_config"""			)
         __A             =		kwargs.pop("""vision_config"""			)

         __A             =		text_config.pop("""model_type"""			)
         __A             =		vision_config.pop("""model_type"""			)

         from transformers import AutoConfig

         __A             =		AutoConfig.for_model(UpperCamelCase_	,		**UpperCamelCase_			)

         if vision_model_type == "clip":
             __A             =		AutoConfig.for_model(UpperCamelCase_	,		**UpperCamelCase_			).vision_config
         elif vision_model_type == "clip_vision_model":
             from transformers import CLIPVisionConfig

             __A             =		CLIPVisionConfig(**UpperCamelCase_			)
         else:
             __A             =		AutoConfig.for_model(UpperCamelCase_	,		**UpperCamelCase_			)

         __A             =		projection_dim
         __A             =		1.0




     @classmethod
     def 						lowerCAmelCase_       (			cls    :     int	,		UpperCamelCase_    :     PretrainedConfig	,		UpperCamelCase_    :     PretrainedConfig	,		**UpperCamelCase_    :     Union[str, Any]			):


         """simple docstring"""



         return cls(text_config=text_config.to_dict()	,		vision_config=vision_config.to_dict()	,		**UpperCamelCase_			)





     def 						lowerCAmelCase_       (			self    :     Tuple			):


         """simple docstring"""



         __A             =		copy.deepcopy(self.__dict__			)
         __A             =		self.text_config.to_dict()
         __A             =		self.vision_config.to_dict()
         __A             =		self.__class__.model_type
         return output




