




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




					'''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.02,  __UpperCamelCase=1E-5,  __UpperCamelCase=True,  __UpperCamelCase=None,  __UpperCamelCase=True,  __UpperCamelCase=10,  __UpperCamelCase=["stage1", "stage2"],  __UpperCamelCase=[1, 2],  ):
							_snake_case     	=	parent
							_snake_case     	=	batch_size
							_snake_case     	=	image_size
							_snake_case     	=	patch_size
							_snake_case     	=	num_channels
							_snake_case     	=	embed_dim
							_snake_case     	=	depths
							_snake_case     	=	num_heads
							_snake_case     	=	kernel_size
							_snake_case     	=	dilations
							_snake_case     	=	mlp_ratio
							_snake_case     	=	qkv_bias
							_snake_case     	=	hidden_dropout_prob
							_snake_case     	=	attention_probs_dropout_prob
							_snake_case     	=	drop_path_rate
							_snake_case     	=	hidden_act
							_snake_case     	=	patch_norm
							_snake_case     	=	layer_norm_eps
							_snake_case     	=	initializer_range
							_snake_case     	=	is_training
							_snake_case     	=	scope
							_snake_case     	=	use_labels
							_snake_case     	=	num_labels
							_snake_case     	=	out_features
							_snake_case     	=	out_indices






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case     	=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

							_snake_case     	=	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			):
							_snake_case     	=	DinatModel(config=__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()
							_snake_case     	=	model(__UpperCamelCase			)

							_snake_case     	=	_snake_case     	=	(config.image_size // config.patch_size) // (2 ** (len(config.depths			) - 1))
							_snake_case     	=	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			):
							_snake_case     	=	DinatForImageClassification(__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()
							_snake_case     	=	model(__UpperCamelCase,  labels=__UpperCamelCase			)
							self.parent.assertEqual(result.logits.shape,  (self.batch_size, self.num_labels)			)

							# test greyscale images
							_snake_case     	=	1
							_snake_case     	=	DinatForImageClassification(__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()

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






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			):
							_snake_case     	=	DinatBackbone(config=__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()
							_snake_case     	=	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
							_snake_case     	=	None
							_snake_case     	=	DinatBackbone(config=__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()
							_snake_case     	=	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			):
							_snake_case     	=	self.prepare_config_and_inputs()
							_snake_case	,   _snake_case	,   _snake_case     	=	config_and_inputs
							_snake_case     	=	{"pixel_values": pixel_values}
							return config, inputs_dict





@require_natten
@require_torch
class 					lowerCamelCase_							(	UpperCAmelCase_,	UpperCAmelCase_,	unittest.TestCase							):




					'''simple docstring'''






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

					lowercase__   =			False
					lowercase__   =			False
					lowercase__   =			False
					lowercase__   =			False






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case     	=	DinatModelTester(self			)
							_snake_case     	=	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			):
							_snake_case     	=	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__UpperCamelCase			)






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case     	=	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase			)






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case     	=	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			):
							_snake_case	,   _snake_case     	=	self.model_tester.prepare_config_and_inputs_for_common()

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






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case	,   _snake_case     	=	self.model_tester.prepare_config_and_inputs_for_common()

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

									_snake_case     	=	["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			):
							_snake_case     	=	model_class(__UpperCamelCase			)
							model.to(__UpperCamelCase			)
							model.eval()

							with torch.no_grad():
									_snake_case     	=	model(**self._prepare_for_class(__UpperCamelCase,  __UpperCamelCase			)			)

							_snake_case     	=	outputs.hidden_states

							_snake_case     	=	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
							_snake_case     	=	(
							    config.patch_size
							    if isinstance(config.patch_size,  collections.abc.Iterable			)
							    else (config.patch_size, config.patch_size)
							)

							_snake_case     	=	image_size[0] // patch_size[0]
							_snake_case     	=	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":
									_snake_case     	=	outputs.reshaped_hidden_states
									self.assertEqual(len(__UpperCamelCase			),  __UpperCamelCase			)

									_snake_case	,   _snake_case	,   _snake_case	,   _snake_case     	=	reshaped_hidden_states[0].shape
									_snake_case     	=	(
									    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			):
							_snake_case	,   _snake_case     	=	self.model_tester.prepare_config_and_inputs_for_common()

							_snake_case     	=	(
							    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:
									_snake_case     	=	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"]
									_snake_case     	=	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]:
									_snake_case     	=	DinatModel.from_pretrained(__UpperCamelCase			)
									self.assertIsNotNone(__UpperCamelCase			)






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case	,   _snake_case     	=	self.model_tester.prepare_config_and_inputs_for_common()

							_snake_case     	=	_config_zero_init(__UpperCamelCase			)
							for model_class in self.all_model_classes:
									_snake_case     	=	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 					lowerCamelCase_							(	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			):
							_snake_case     	=	DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224"			).to(__UpperCamelCase			)
							_snake_case     	=	self.default_image_processor

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

							# forward pass
							with torch.no_grad():
									_snake_case     	=	model(**__UpperCamelCase			)

							# verify the logits
							_snake_case     	=	torch.Size((1, 1_000)			)
							self.assertEqual(outputs.logits.shape,  __UpperCamelCase			)
							_snake_case     	=	torch.tensor([-0.15_45, -0.76_67, 0.46_42]			).to(__UpperCamelCase			)
							self.assertTrue(torch.allclose(outputs.logits[0, :3],  __UpperCamelCase,  atol=1E-4			)			)





@require_torch
@require_natten
class 					lowerCamelCase_							(	unittest.TestCase,	UpperCAmelCase_							):




					'''simple docstring'''






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






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











'''simple docstring'''







import math





class 					lowerCamelCase_							:




					'''simple docstring'''






					def __init__(   self,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			):
							_snake_case     	=	x
							_snake_case     	=	y
							_snake_case     	=	z






					def __repr__(   self			):
							return f'''Point({self.x}, {self.y}, {self.z})'''






def 		_lowercase		(     lowercase_						,							lowercase_  ):



		'''simple docstring'''







		return math.sqrt(abs((b.x - a.x) ** 2 + (b.y - a.y) ** 2 + (b.z - a.z) ** 2  )  )


if __name__ == "__main__":
						import doctest

						doctest.testmod()





