






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

					"""simple docstring"""





					def __init__(     self   , UpperCAmelCase__   , UpperCAmelCase__=13   , UpperCAmelCase__=64   , UpperCAmelCase__=4   , UpperCAmelCase__=3   , UpperCAmelCase__=16   , UpperCAmelCase__=[1, 2, 1]   , UpperCAmelCase__=[2, 4, 8]   , UpperCAmelCase__=3   , UpperCAmelCase__=[[3], [1, 2], [1]]   , UpperCAmelCase__=2.0   , UpperCAmelCase__=True   , UpperCAmelCase__=0.0   , UpperCAmelCase__=0.0   , UpperCAmelCase__=0.1   , UpperCAmelCase__="gelu"   , UpperCAmelCase__=True   , UpperCAmelCase__=0.0_2   , UpperCAmelCase__=1e-5   , UpperCAmelCase__=True   , UpperCAmelCase__=None   , UpperCAmelCase__=True   , UpperCAmelCase__=10   , UpperCAmelCase__=["stage1", "stage2"]   , UpperCAmelCase__=[1, 2]   , ):
										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  __SCREAMING_SNAKE_CASE (     self     ):
										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  __SCREAMING_SNAKE_CASE (     self     ):
										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  __SCREAMING_SNAKE_CASE (     self   , UpperCAmelCase__   , UpperCAmelCase__   , UpperCAmelCase__     ):
										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  __SCREAMING_SNAKE_CASE (     self   , UpperCAmelCase__   , UpperCAmelCase__   , UpperCAmelCase__     ):
										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  __SCREAMING_SNAKE_CASE (     self   , UpperCAmelCase__   , UpperCAmelCase__   , UpperCAmelCase__     ):
										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  __SCREAMING_SNAKE_CASE (     self     ):
										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    _snake_case   (				snake_case     ,					snake_case     ,					unittest.TestCase					):

					"""simple docstring"""





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

					_UpperCamelCase		 =      False
					_UpperCamelCase		 =      False
					_UpperCamelCase		 =      False
					_UpperCamelCase		 =      False




					def  __SCREAMING_SNAKE_CASE (     self     ):
										a_									=   DinatModelTester(self     )
										a_									=   ConfigTester(self   , config_class=UpperCAmelCase__   , embed_dim=37     )




					def  __SCREAMING_SNAKE_CASE (     self     ):
										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  __SCREAMING_SNAKE_CASE (     self     ):
										return




					def  __SCREAMING_SNAKE_CASE (     self     ):
										a_									=   self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCAmelCase__     )




					def  __SCREAMING_SNAKE_CASE (     self     ):
										a_									=   self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__     )




					def  __SCREAMING_SNAKE_CASE (     self     ):
										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  __SCREAMING_SNAKE_CASE (     self     ):
										pass




					@unittest.skip(reason='Dinat does not use feedforward chunking'     )
					def  __SCREAMING_SNAKE_CASE (     self     ):
										pass




					def  __SCREAMING_SNAKE_CASE (     self     ):
										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  __SCREAMING_SNAKE_CASE (     self     ):
										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  __SCREAMING_SNAKE_CASE (     self     ):
										self.skipTest('Dinat\'s attention operation is handled entirely by NATTEN.'     )




					def  __SCREAMING_SNAKE_CASE (     self   , UpperCAmelCase__   , UpperCAmelCase__   , UpperCAmelCase__   , UpperCAmelCase__     ):
										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  __SCREAMING_SNAKE_CASE (     self     ):
										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  __SCREAMING_SNAKE_CASE (     self     ):
										for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															a_									=   DinatModel.from_pretrained(UpperCAmelCase__     )
															self.assertIsNotNone(UpperCAmelCase__     )




					def  __SCREAMING_SNAKE_CASE (     self     ):
										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    _snake_case   (				unittest.TestCase					):

					"""simple docstring"""





					@cached_property
					def  __SCREAMING_SNAKE_CASE (     self     ):
										return AutoImageProcessor.from_pretrained('shi-labs/dinat-mini-in1k-224'     ) if is_vision_available() else None




					@slow
					def  __SCREAMING_SNAKE_CASE (     self     ):
										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, 1000)     )
										self.assertEqual(outputs.logits.shape   , UpperCAmelCase__     )
										a_									=   torch.tensor([-0.1_5_4_5, -0.7_6_6_7, 0.4_6_4_2]     ).to(UpperCAmelCase__     )
										self.assertTrue(torch.allclose(outputs.logits[0, :3]   , UpperCAmelCase__   , atol=1e-4     )     )



@require_torch
@require_natten
class    _snake_case   (				unittest.TestCase     ,					snake_case					):

					"""simple docstring"""





					_UpperCamelCase		 =      (DinatBackbone,) if is_torch_available() else ()
					_UpperCamelCase		 =      DinatConfig




					def  __SCREAMING_SNAKE_CASE (     self     ):
										a_									=   DinatModelTester(self     )









'''simple docstring'''
def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) * 9 / 5) + 3_2					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round(float(_UpperCAmelCase ) + 2_7_3.1_5					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) * 9 / 5) + 4_9_1.6_7					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) - 3_2) * 5 / 9					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round(((float(_UpperCAmelCase ) - 3_2) * 5 / 9) + 2_7_3.1_5					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round(float(_UpperCAmelCase ) + 4_5_9.6_7					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round(float(_UpperCAmelCase ) - 2_7_3.1_5					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round(((float(_UpperCAmelCase ) - 2_7_3.1_5) * 9 / 5) + 3_2					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) * 9 / 5)					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) - 4_9_1.6_7) * 5 / 9					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round(float(_UpperCAmelCase ) - 4_5_9.6_7					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) * 5 / 9)					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) * 1.2_5 + 2_7_3.1_5)					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) * 2.2_5 + 3_2)					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) * 1.2_5)					,  _UpperCAmelCase )

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = 2 )				->				float:






					"""simple docstring"""







					return round((float(_UpperCAmelCase ) * 2.2_5 + 3_2 + 4_5_9.6_7)					,  _UpperCAmelCase )


if __name__ == "__main__":
						import doctest

						doctest.testmod()

