


"""simple docstring"""






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     A:

		"""simple docstring"""





		def __init__(   self				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__=13				,							SCREAMING_SNAKE_CASE__=64				,							SCREAMING_SNAKE_CASE__=4				,							SCREAMING_SNAKE_CASE__=3				,							SCREAMING_SNAKE_CASE__=16				,							SCREAMING_SNAKE_CASE__=[1, 2, 1]				,							SCREAMING_SNAKE_CASE__=[2, 4, 8]				,							SCREAMING_SNAKE_CASE__=3				,							SCREAMING_SNAKE_CASE__=[[3], [1, 2], [1]]				,							SCREAMING_SNAKE_CASE__=2.0				,							SCREAMING_SNAKE_CASE__=True				,							SCREAMING_SNAKE_CASE__=0.0				,							SCREAMING_SNAKE_CASE__=0.0				,							SCREAMING_SNAKE_CASE__=0.1				,							SCREAMING_SNAKE_CASE__="gelu"				,							SCREAMING_SNAKE_CASE__=True				,							SCREAMING_SNAKE_CASE__=0.0_2				,							SCREAMING_SNAKE_CASE__=1E-5				,							SCREAMING_SNAKE_CASE__=True				,							SCREAMING_SNAKE_CASE__=None				,							SCREAMING_SNAKE_CASE__=True				,							SCREAMING_SNAKE_CASE__=10				,							SCREAMING_SNAKE_CASE__=["stage1", "stage2"]				,							SCREAMING_SNAKE_CASE__=[1, 2]				,							)			->  Dict:

					"""simple docstring"""



					_UpperCamelCase				:List[str]				    =  parent
					_UpperCamelCase				:int				    =  batch_size
					_UpperCamelCase				:int				    =  image_size
					_UpperCamelCase				:str				    =  patch_size
					_UpperCamelCase				:List[str]				    =  num_channels
					_UpperCamelCase				:Dict				    =  embed_dim
					_UpperCamelCase				:Dict				    =  depths
					_UpperCamelCase				:Union[str, Any]				    =  num_heads
					_UpperCamelCase				:Union[str, Any]				    =  kernel_size
					_UpperCamelCase				:str				    =  dilations
					_UpperCamelCase				:Any				    =  mlp_ratio
					_UpperCamelCase				:List[Any]				    =  qkv_bias
					_UpperCamelCase				:Tuple				    =  hidden_dropout_prob
					_UpperCamelCase				:str				    =  attention_probs_dropout_prob
					_UpperCamelCase				:Optional[Any]				    =  drop_path_rate
					_UpperCamelCase				:Any				    =  hidden_act
					_UpperCamelCase				:Dict				    =  patch_norm
					_UpperCamelCase				:str				    =  layer_norm_eps
					_UpperCamelCase				:List[Any]				    =  initializer_range
					_UpperCamelCase				:Optional[int]				    =  is_training
					_UpperCamelCase				:List[Any]				    =  scope
					_UpperCamelCase				:Optional[Any]				    =  use_labels
					_UpperCamelCase				:Any				    =  num_labels
					_UpperCamelCase				:Any				    =  out_features
					_UpperCamelCase				:Optional[Any]				    =  out_indices
		def      _UpperCamelCase(   self      )			->  List[str]:

					"""simple docstring"""



					_UpperCamelCase				:Optional[Any]				    =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

					_UpperCamelCase				:Tuple				    =  None
					if self.use_labels:
								_UpperCamelCase				:Optional[Any]				    =  ids_tensor([self.batch_size]				,							self.num_labels      )

					_UpperCamelCase				:Union[str, Any]				    =  self.get_config()

					return config, pixel_values, labels
		def      _UpperCamelCase(   self      )			->  int:

					"""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      _UpperCamelCase(   self				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__      )			->  Any:

					"""simple docstring"""



					_UpperCamelCase				:Optional[Any]				    =  DinatModel(config=SCREAMING_SNAKE_CASE__      )
					model.to(SCREAMING_SNAKE_CASE__      )
					model.eval()
					_UpperCamelCase				:Dict				    =  model(SCREAMING_SNAKE_CASE__      )

					_UpperCamelCase				:Dict				    =  (config.image_size // config.patch_size) // (2 ** (len(config.depths      ) - 1))
					_UpperCamelCase				:Union[str, Any]				    =  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      _UpperCamelCase(   self				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__      )			->  Tuple:

					"""simple docstring"""



					_UpperCamelCase				:List[Any]				    =  DinatForImageClassification(SCREAMING_SNAKE_CASE__      )
					model.to(SCREAMING_SNAKE_CASE__      )
					model.eval()
					_UpperCamelCase				:Union[str, Any]				    =  model(SCREAMING_SNAKE_CASE__				,							labels=SCREAMING_SNAKE_CASE__      )
					self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.num_labels)      )

					# test greyscale images
					_UpperCamelCase				:Dict				    =  1
					_UpperCamelCase				:Optional[Any]				    =  DinatForImageClassification(SCREAMING_SNAKE_CASE__      )
					model.to(SCREAMING_SNAKE_CASE__      )
					model.eval()

					_UpperCamelCase				:Optional[int]				    =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
					_UpperCamelCase				:Union[str, Any]				    =  model(SCREAMING_SNAKE_CASE__      )
					self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.num_labels)      )
		def      _UpperCamelCase(   self				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__      )			->  Tuple:

					"""simple docstring"""



					_UpperCamelCase				:str				    =  DinatBackbone(config=SCREAMING_SNAKE_CASE__      )
					model.to(SCREAMING_SNAKE_CASE__      )
					model.eval()
					_UpperCamelCase				:Optional[Any]				    =  model(SCREAMING_SNAKE_CASE__      )

					# 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
					_UpperCamelCase				:Union[str, Any]				    =  None
					_UpperCamelCase				:Any				    =  DinatBackbone(config=SCREAMING_SNAKE_CASE__      )
					model.to(SCREAMING_SNAKE_CASE__      )
					model.eval()
					_UpperCamelCase				:Optional[int]				    =  model(SCREAMING_SNAKE_CASE__      )

					# 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      _UpperCamelCase(   self      )			->  Any:

					"""simple docstring"""



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






@require_natten
@require_torch
class     A(     lowerCamelCase__							,       lowerCamelCase__							,       unittest.TestCase		):

		"""simple docstring"""





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

		A         =       False
		A         =       False
		A         =       False
		A         =       False
		def      _UpperCamelCase(   self      )			->  Union[str, Any]:

					"""simple docstring"""



					_UpperCamelCase				:List[str]				    =  DinatModelTester(self      )
					_UpperCamelCase				:Any				    =  ConfigTester(self				,							config_class=SCREAMING_SNAKE_CASE__				,							embed_dim=37      )
		def      _UpperCamelCase(   self      )			->  Tuple:

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

					"""simple docstring"""



					return
		def      _UpperCamelCase(   self      )			->  Optional[int]:

					"""simple docstring"""



					_UpperCamelCase				:Dict				    =  self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__      )
		def      _UpperCamelCase(   self      )			->  Dict:

					"""simple docstring"""



					_UpperCamelCase				:Dict				    =  self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__      )
		def      _UpperCamelCase(   self      )			->  Dict:

					"""simple docstring"""



					_UpperCamelCase				:Any				    =  self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE__      )
		@unittest.skip(reason='''Dinat does not use inputs_embeds'''      )
		def      _UpperCamelCase(   self      )			->  str:

					"""simple docstring"""



					pass
		@unittest.skip(reason='''Dinat does not use feedforward chunking'''      )
		def      _UpperCamelCase(   self      )			->  List[Any]:

					"""simple docstring"""



					pass
		def      _UpperCamelCase(   self      )			->  Tuple:

					"""simple docstring"""



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

					for model_class in self.all_model_classes:
								_UpperCamelCase				:List[str]				    =  model_class(SCREAMING_SNAKE_CASE__      )
								self.assertIsInstance(model.get_input_embeddings()				,							(nn.Module)      )
								_UpperCamelCase				:Any				    =  model.get_output_embeddings()
								self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE__				,							nn.Linear      )      )
		def      _UpperCamelCase(   self      )			->  Dict:

					"""simple docstring"""



					_UpperCamelCase    ,			_UpperCamelCase				:Tuple				    =  self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
								_UpperCamelCase				:Tuple				    =  model_class(SCREAMING_SNAKE_CASE__      )
								_UpperCamelCase				:Optional[int]				    =  inspect.signature(model.forward      )
								# signature.parameters is an OrderedDict => so arg_names order is deterministic
								_UpperCamelCase				:str				    =  [*signature.parameters.keys()]

								_UpperCamelCase				:Tuple				    =  ['''pixel_values''']
								self.assertListEqual(arg_names[:1]				,							SCREAMING_SNAKE_CASE__      )
		def      _UpperCamelCase(   self      )			->  Tuple:

					"""simple docstring"""



					self.skipTest('''Dinat\'s attention operation is handled entirely by NATTEN.'''      )
		def      _UpperCamelCase(   self				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__      )			->  str:

					"""simple docstring"""



					_UpperCamelCase				:Optional[Any]				    =  model_class(SCREAMING_SNAKE_CASE__      )
					model.to(SCREAMING_SNAKE_CASE__      )
					model.eval()

					with torch.no_grad():
								_UpperCamelCase				:Optional[int]				    =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__      )      )

					_UpperCamelCase				:str				    =  outputs.hidden_states

					_UpperCamelCase				:Optional[Any]				    =  getattr(
					    self.model_tester				,							'''expected_num_hidden_layers'''				,							len(self.model_tester.depths      ) + 1      )
					self.assertEqual(len(SCREAMING_SNAKE_CASE__      )				,							SCREAMING_SNAKE_CASE__      )

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

					_UpperCamelCase				:Optional[Any]				    =  image_size[0] // patch_size[0]
					_UpperCamelCase				:Union[str, Any]				    =  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":
								_UpperCamelCase				:Union[str, Any]				    =  outputs.reshaped_hidden_states
								self.assertEqual(len(SCREAMING_SNAKE_CASE__      )				,							SCREAMING_SNAKE_CASE__      )

								_UpperCamelCase    ,			_UpperCamelCase    ,			_UpperCamelCase    ,			_UpperCamelCase				:Optional[Any]				    =  reshaped_hidden_states[0].shape
								_UpperCamelCase				:Tuple				    =  (
								    reshaped_hidden_states[0].view(SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__      ).permute(0				,							2				,							3				,							1      )
								)
								self.assertListEqual(
								    list(reshaped_hidden_states.shape[-3:]      )				,							[height, width, self.model_tester.embed_dim]				,							)
		def      _UpperCamelCase(   self      )			->  Union[str, Any]:

					"""simple docstring"""



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

					_UpperCamelCase				:Dict				    =  (
					    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:
								_UpperCamelCase				:Union[str, Any]				    =  True
								self.check_hidden_states_output(SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__      )

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

								self.check_hidden_states_output(SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__				,							SCREAMING_SNAKE_CASE__      )
		@slow
		def      _UpperCamelCase(   self      )			->  str:

					"""simple docstring"""



					for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								_UpperCamelCase				:List[str]				    =  DinatModel.from_pretrained(SCREAMING_SNAKE_CASE__      )
								self.assertIsNotNone(SCREAMING_SNAKE_CASE__      )





		def      _UpperCamelCase(   self      )			->  List[str]:

					"""simple docstring"""



					_UpperCamelCase    ,			_UpperCamelCase				:Tuple				    =  self.model_tester.prepare_config_and_inputs_for_common()

					_UpperCamelCase				:List[Any]				    =  _config_zero_init(SCREAMING_SNAKE_CASE__      )
					for model_class in self.all_model_classes:
								_UpperCamelCase				:List[str]				    =  model_class(config=SCREAMING_SNAKE_CASE__      )
								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     A(     unittest.TestCase		):

		"""simple docstring"""





		@cached_property
		def      _UpperCamelCase(   self      )			->  Tuple:

					"""simple docstring"""



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





		@slow
		def      _UpperCamelCase(   self      )			->  Any:

					"""simple docstring"""



					_UpperCamelCase				:List[Any]				    =  DinatForImageClassification.from_pretrained('''shi-labs/dinat-mini-in1k-224'''      ).to(SCREAMING_SNAKE_CASE__      )
					_UpperCamelCase				:str				    =  self.default_image_processor

					_UpperCamelCase				:List[Any]				    =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
					_UpperCamelCase				:List[Any]				    =  image_processor(images=SCREAMING_SNAKE_CASE__				,							return_tensors='''pt'''      ).to(SCREAMING_SNAKE_CASE__      )

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

					# verify the logits
					_UpperCamelCase				:Dict				    =  torch.Size((1, 10_00)      )
					self.assertEqual(outputs.logits.shape				,							SCREAMING_SNAKE_CASE__      )
					_UpperCamelCase				:Dict				    =  torch.tensor([-0.1_5_4_5, -0.7_6_6_7, 0.4_6_4_2]      ).to(SCREAMING_SNAKE_CASE__      )
					self.assertTrue(torch.allclose(outputs.logits[0, :3]				,							SCREAMING_SNAKE_CASE__				,							atol=1E-4      )      )






@require_torch
@require_natten
class     A(     unittest.TestCase							,       lowerCamelCase__		):

		"""simple docstring"""





		A         =       (DinatBackbone,) if is_torch_available() else ()
		A         =       DinatConfig
		def      _UpperCamelCase(   self      )			->  List[str]:

					"""simple docstring"""



					_UpperCamelCase				:int				    =  DinatModelTester(self      )





"""simple docstring"""






from __future__ import annotations

from enum import Enum






class     A(     lowerCamelCase__		):

		"""simple docstring"""





		A         =       24
		A         =       21
		A         =       18
		A         =       15
		A         =       12
		A         =       9
		A         =       6
		A         =       3
		A         =       2
		A         =       1
		A         =       -1
		A         =       -2
		A         =       -3
		A         =       -6
		A         =       -9
		A         =       -12
		A         =       -15
		A         =       -18
		A         =       -21
		A         =       -24






class     A(     lowerCamelCase__		):

		"""simple docstring"""





		A         =       8
		A         =       7
		A         =       6
		A         =       5
		A         =       4
		A         =       3
		A         =       2
		A         =       1





def 							A_					(   snake_case__					,				snake_case__					,				snake_case__					,				)				->     float:
			if isinstance(snake_case__					,				snake_case__		):
						_UpperCamelCase				:Tuple				    =  SIUnit[known_prefix.lower()]
			if isinstance(snake_case__					,				snake_case__		):
						_UpperCamelCase				:Optional[int]				    =  SIUnit[unknown_prefix.lower()]
			_UpperCamelCase				:float				    =  known_amount * (
			    10 ** (known_prefix.value - unknown_prefix.value)
			)
			return unknown_amount





def 							A_					(   snake_case__					,				snake_case__					,				snake_case__					,				)				->     float:
			if isinstance(snake_case__					,				snake_case__		):
						_UpperCamelCase				:Any				    =  BinaryUnit[known_prefix.lower()]
			if isinstance(snake_case__					,				snake_case__		):
						_UpperCamelCase				:Dict				    =  BinaryUnit[unknown_prefix.lower()]
			_UpperCamelCase				:float				    =  known_amount * (
			    2 ** ((known_prefix.value - unknown_prefix.value) * 10)
			)
			return unknown_amount


if __name__ == "__main__":
					import doctest

					doctest.testmod()

