




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     :



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





								'''simple docstring'''




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



				def 					SCREAMING_SNAKE_CASE				(					self					:						Dict					)     ->			List[Any]:





								'''simple docstring'''




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

								_lowerCAmelCase			:			str        =					None
								if self.use_labels:
												_lowerCAmelCase			:			Tuple        =					ids_tensor([self.batch_size]						,		self.num_labels					)

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

								return config, pixel_values, labels



				def 					SCREAMING_SNAKE_CASE				(					self					:						int					)     ->			Optional[Any]:





								'''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 					SCREAMING_SNAKE_CASE				(					self					:						Tuple						,		_UpperCAmelCase					:						Union[str, Any]						,		_UpperCAmelCase					:						Tuple						,		_UpperCAmelCase					:						int					)     ->			Tuple:





								'''simple docstring'''




								_lowerCAmelCase			:			Dict        =					DinatModel(config=_UpperCAmelCase					)
								model.to(_UpperCAmelCase					)
								model.eval()
								_lowerCAmelCase			:			List[str]        =					model(_UpperCAmelCase					)

								_lowerCAmelCase			:			Any        =					(config.image_size // config.patch_size) // (2 ** (len(config.depths					) - 1))
								_lowerCAmelCase			:			int        =					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					:						Optional[Any]						,		_UpperCAmelCase					:						Union[str, Any]						,		_UpperCAmelCase					:						List[str]						,		_UpperCAmelCase					:						Any					)     ->			Optional[Any]:





								'''simple docstring'''




								_lowerCAmelCase			:			int        =					DinatForImageClassification(_UpperCAmelCase					)
								model.to(_UpperCAmelCase					)
								model.eval()
								_lowerCAmelCase			:			Tuple        =					model(_UpperCAmelCase						,		labels=_UpperCAmelCase					)
								self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.num_labels)					)

								# test greyscale images
								_lowerCAmelCase			:			Tuple        =					1
								_lowerCAmelCase			:			List[str]        =					DinatForImageClassification(_UpperCAmelCase					)
								model.to(_UpperCAmelCase					)
								model.eval()

								_lowerCAmelCase			:			List[str]        =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
								_lowerCAmelCase			:			List[str]        =					model(_UpperCAmelCase					)
								self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.num_labels)					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						Any						,		_UpperCAmelCase					:						Any						,		_UpperCAmelCase					:						List[Any]						,		_UpperCAmelCase					:						Tuple					)     ->			Dict:





								'''simple docstring'''




								_lowerCAmelCase			:			List[Any]        =					DinatBackbone(config=_UpperCAmelCase					)
								model.to(_UpperCAmelCase					)
								model.eval()
								_lowerCAmelCase			:			List[str]        =					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
								_lowerCAmelCase			:			Tuple        =					None
								_lowerCAmelCase			:			Tuple        =					DinatBackbone(config=_UpperCAmelCase					)
								model.to(_UpperCAmelCase					)
								model.eval()
								_lowerCAmelCase			:			Any        =					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					:						Union[str, Any]					)     ->			Optional[Any]:





								'''simple docstring'''




								_lowerCAmelCase			:			int        =					self.prepare_config_and_inputs()
								_lowerCAmelCase    ,			_lowerCAmelCase    ,			_lowerCAmelCase			:			Tuple        =					config_and_inputs
								_lowerCAmelCase			:			Dict        =					{"""pixel_values""": pixel_values}
								return config, inputs_dict






@require_natten
@require_torch
class 				__snake_case     (_a  ,		_a  ,		unittest.TestCase						):
				lowerCAmelCase__			=   (
				    (
				        DinatModel,
				        DinatForImageClassification,
				        DinatBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				lowerCAmelCase__			=   (
				    {"feature-extraction": DinatModel, "image-classification": DinatForImageClassification}
				    if is_torch_available()
				    else {}
				)
				lowerCAmelCase__			=   False

				lowerCAmelCase__			=   False
				lowerCAmelCase__			=   False
				lowerCAmelCase__			=   False
				lowerCAmelCase__			=   False



				def 					SCREAMING_SNAKE_CASE				(					self					:						str					)     ->			Dict:





								'''simple docstring'''




								_lowerCAmelCase			:			Optional[Any]        =					DinatModelTester(self					)
								_lowerCAmelCase			:			Dict        =					ConfigTester(self						,		config_class=_UpperCAmelCase						,		embed_dim=37					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						Tuple					)     ->			Union[str, Any]:





								'''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 					SCREAMING_SNAKE_CASE				(					self					:						Union[str, Any]					)     ->			Optional[int]:





								'''simple docstring'''




								return



				def 					SCREAMING_SNAKE_CASE				(					self					:						str					)     ->			str:





								'''simple docstring'''




								_lowerCAmelCase			:			Tuple        =					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_UpperCAmelCase					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						List[Any]					)     ->			Any:





								'''simple docstring'''




								_lowerCAmelCase			:			str        =					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						Tuple					)     ->			int:





								'''simple docstring'''




								_lowerCAmelCase			:			Any        =					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					:						int					)     ->			Any:





								'''simple docstring'''




								pass



				@unittest.skip(reason="""Dinat does not use feedforward chunking"""					)
				def 					SCREAMING_SNAKE_CASE				(					self					:						int					)     ->			Union[str, Any]:





								'''simple docstring'''




								pass



				def 					SCREAMING_SNAKE_CASE				(					self					:						Optional[Any]					)     ->			Tuple:





								'''simple docstring'''




								_lowerCAmelCase    ,			_lowerCAmelCase			:			Optional[Any]        =					self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
												_lowerCAmelCase			:			List[str]        =					model_class(_UpperCAmelCase					)
												self.assertIsInstance(model.get_input_embeddings()						,		(nn.Module)					)
												_lowerCAmelCase			:			Union[str, Any]        =					model.get_output_embeddings()
												self.assertTrue(x is None or isinstance(_UpperCAmelCase						,		nn.Linear					)					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						Dict					)     ->			str:





								'''simple docstring'''




								_lowerCAmelCase    ,			_lowerCAmelCase			:			Dict        =					self.model_tester.prepare_config_and_inputs_for_common()

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

												_lowerCAmelCase			:			List[str]        =					["""pixel_values"""]
												self.assertListEqual(arg_names[:1]						,		_UpperCAmelCase					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						Optional[int]					)     ->			Union[str, Any]:





								'''simple docstring'''




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



				def 					SCREAMING_SNAKE_CASE				(					self					:						Union[str, Any]						,		_UpperCAmelCase					:						Union[str, Any]						,		_UpperCAmelCase					:						Dict						,		_UpperCAmelCase					:						Optional[int]						,		_UpperCAmelCase					:						Any					)     ->			Optional[Any]:





								'''simple docstring'''




								_lowerCAmelCase			:			Optional[Any]        =					model_class(_UpperCAmelCase					)
								model.to(_UpperCAmelCase					)
								model.eval()

								with torch.no_grad():
												_lowerCAmelCase			:			Tuple        =					model(**self._prepare_for_class(_UpperCAmelCase						,		_UpperCAmelCase					)					)

								_lowerCAmelCase			:			Any        =					outputs.hidden_states

								_lowerCAmelCase			:			Any        =					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
								_lowerCAmelCase			:			Optional[int]        =					(
								    config.patch_size
								    if isinstance(config.patch_size						,		collections.abc.Iterable					)
								    else (config.patch_size, config.patch_size)
								)

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

												_lowerCAmelCase    ,			_lowerCAmelCase    ,			_lowerCAmelCase    ,			_lowerCAmelCase			:			int        =					reshaped_hidden_states[0].shape
												_lowerCAmelCase			:			int        =					(
												    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					:						str					)     ->			Tuple:





								'''simple docstring'''




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

								_lowerCAmelCase			:			int        =					(
								    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:
												_lowerCAmelCase			:			int        =					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"]
												_lowerCAmelCase			:			Optional[int]        =					True

												self.check_hidden_states_output(_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase					)



				@slow
				def 					SCREAMING_SNAKE_CASE				(					self					:						int					)     ->			str:





								'''simple docstring'''




								for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_lowerCAmelCase			:			Union[str, Any]        =					DinatModel.from_pretrained(_UpperCAmelCase					)
												self.assertIsNotNone(_UpperCAmelCase					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						Any					)     ->			List[str]:





								'''simple docstring'''




								_lowerCAmelCase    ,			_lowerCAmelCase			:			Optional[int]        =					self.model_tester.prepare_config_and_inputs_for_common()

								_lowerCAmelCase			:			str        =					_config_zero_init(_UpperCAmelCase					)
								for model_class in self.all_model_classes:
												_lowerCAmelCase			:			Optional[int]        =					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						):



				@cached_property
				def 					SCREAMING_SNAKE_CASE				(					self					:						Tuple					)     ->			Union[str, Any]:





								'''simple docstring'''




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



				@slow
				def 					SCREAMING_SNAKE_CASE				(					self					:						str					)     ->			List[Any]:





								'''simple docstring'''




								_lowerCAmelCase			:			Dict        =					DinatForImageClassification.from_pretrained("""shi-labs/dinat-mini-in1k-224"""					).to(_UpperCAmelCase					)
								_lowerCAmelCase			:			Any        =					self.default_image_processor

								_lowerCAmelCase			:			List[str]        =					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
								_lowerCAmelCase			:			Any        =					image_processor(images=_UpperCAmelCase						,		return_tensors="""pt"""					).to(_UpperCAmelCase					)

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

								# verify the logits
								_lowerCAmelCase			:			Any        =					torch.Size((1, 1000)					)
								self.assertEqual(outputs.logits.shape						,		_UpperCAmelCase					)
								_lowerCAmelCase			:			int        =					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 				__snake_case     (unittest.TestCase  ,		_a						):
				lowerCAmelCase__			=   (DinatBackbone,) if is_torch_available() else ()
				lowerCAmelCase__			=   DinatConfig



				def 					SCREAMING_SNAKE_CASE				(					self					:						Dict					)     ->			Optional[Any]:





								'''simple docstring'''




								_lowerCAmelCase			:			Tuple        =					DinatModelTester(self					)


"""simple docstring"""


from __future__ import annotations





def 			lowerCamelCase_ (					__lowerCAmelCase				)							->					int | float:




						'''simple docstring'''



						if len(__lowerCAmelCase				) == 0:
												raise ValueError("find_max() arg is an empty sequence"				)
						lowerCamelCase__					=nums[0]
						for x in nums:
												if x > max_num:
																		lowerCamelCase__					=x
						return max_num


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)


