



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

						def __init__(    self	:int   ,						_lowercase	:List[str]   ,						_lowercase	:Dict=13   ,						_lowercase	:List[Any]=64   ,						_lowercase	:Optional[Any]=4   ,						_lowercase	:List[Any]=3   ,						_lowercase	:str=16   ,						_lowercase	:Tuple=[1, 2, 1]   ,						_lowercase	:str=[2, 4, 8]   ,						_lowercase	:int=3   ,						_lowercase	:Tuple=[[3], [1, 2], [1]]   ,						_lowercase	:Any=2.0   ,						_lowercase	:Optional[Any]=True   ,						_lowercase	:Tuple=0.0   ,						_lowercase	:List[str]=0.0   ,						_lowercase	:Optional[Any]=0.1   ,						_lowercase	:str="gelu"   ,						_lowercase	:int=True   ,						_lowercase	:List[Any]=0.02   ,						_lowercase	:Optional[int]=1E-5   ,						_lowercase	:str=True   ,						_lowercase	:int=None   ,						_lowercase	:Optional[Any]=True   ,						_lowercase	:Optional[Any]=10   ,						_lowercase	:Optional[int]=["stage1", "stage2"]   ,						_lowercase	:str=[1, 2]   ,						)		->					int:
												UpperCAmelCase_     							=     parent
												UpperCAmelCase_     							=     batch_size
												UpperCAmelCase_     							=     image_size
												UpperCAmelCase_     							=     patch_size
												UpperCAmelCase_     							=     num_channels
												UpperCAmelCase_     							=     embed_dim
												UpperCAmelCase_     							=     depths
												UpperCAmelCase_     							=     num_heads
												UpperCAmelCase_     							=     kernel_size
												UpperCAmelCase_     							=     dilations
												UpperCAmelCase_     							=     mlp_ratio
												UpperCAmelCase_     							=     qkv_bias
												UpperCAmelCase_     							=     hidden_dropout_prob
												UpperCAmelCase_     							=     attention_probs_dropout_prob
												UpperCAmelCase_     							=     drop_path_rate
												UpperCAmelCase_     							=     hidden_act
												UpperCAmelCase_     							=     patch_norm
												UpperCAmelCase_     							=     layer_norm_eps
												UpperCAmelCase_     							=     initializer_range
												UpperCAmelCase_     							=     is_training
												UpperCAmelCase_     							=     scope
												UpperCAmelCase_     							=     use_labels
												UpperCAmelCase_     							=     num_labels
												UpperCAmelCase_     							=     out_features
												UpperCAmelCase_     							=     out_indices

						def 	__a       (    self	:Optional[Any])		->					str:
												UpperCAmelCase_     							=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

												UpperCAmelCase_     							=     self.get_config()

												return config, pixel_values, labels

						def 	__a       (    self	:Optional[Any])		->					List[str]:
												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 	__a       (    self	:int   ,						_lowercase	:List[str]   ,						_lowercase	:Optional[Any]   ,						_lowercase	:Optional[Any])		->					Dict:
												UpperCAmelCase_     							=     DinatModel(config=_lowercase)
												model.to(_lowercase)
												model.eval()
												UpperCAmelCase_     							=     model(_lowercase)

												UpperCAmelCase_     							=     UpperCAmelCase_     							=     (config.image_size // config.patch_size) // (2 ** (len(config.depths) - 1))
												UpperCAmelCase_     							=     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 	__a       (    self	:str   ,						_lowercase	:str   ,						_lowercase	:Dict   ,						_lowercase	:List[str])		->					Tuple:
												UpperCAmelCase_     							=     DinatForImageClassification(_lowercase)
												model.to(_lowercase)
												model.eval()
												UpperCAmelCase_     							=     model(_lowercase   ,						labels=_lowercase)
												self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.num_labels))

												# test greyscale images
												UpperCAmelCase_     							=     1
												UpperCAmelCase_     							=     DinatForImageClassification(_lowercase)
												model.to(_lowercase)
												model.eval()

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

						def 	__a       (    self	:List[str]   ,						_lowercase	:Dict   ,						_lowercase	:str   ,						_lowercase	:Dict)		->					Optional[Any]:
												UpperCAmelCase_     							=     DinatBackbone(config=_lowercase)
												model.to(_lowercase)
												model.eval()
												UpperCAmelCase_     							=     model(_lowercase)

												# 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_     							=     None
												UpperCAmelCase_     							=     DinatBackbone(config=_lowercase)
												model.to(_lowercase)
												model.eval()
												UpperCAmelCase_     							=     model(_lowercase)

												# 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 	__a       (    self	:Any)		->					Tuple:
												UpperCAmelCase_     							=     self.prepare_config_and_inputs()
												UpperCAmelCase_							,      UpperCAmelCase_							,      UpperCAmelCase_     							=     config_and_inputs
												UpperCAmelCase_     							=     {'''pixel_values''': pixel_values}
												return config, inputs_dict







@require_natten
@require_torch
class 							a_  (		_snake_case					, _snake_case					, unittest.TestCase				):
						UpperCamelCase__      :						List[str]				       =(
						    (
						        DinatModel,
						        DinatForImageClassification,
						        DinatBackbone,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCamelCase__      :						Union[str, Any]				       =(
						    {"feature-extraction": DinatModel, "image-classification": DinatForImageClassification}
						    if is_torch_available()
						    else {}
						)
						UpperCamelCase__      :						Optional[int]				       =False

						UpperCamelCase__      :						Optional[int]				       =False
						UpperCamelCase__      :						Union[str, Any]				       =False
						UpperCamelCase__      :						Union[str, Any]				       =False
						UpperCamelCase__      :						int				       =False

						def 	__a       (    self	:int)		->					Tuple:
												UpperCAmelCase_     							=     DinatModelTester(self)
												UpperCAmelCase_     							=     ConfigTester(self   ,						config_class=_lowercase   ,						embed_dim=37)

						def 	__a       (    self	:List[str])		->					Any:
												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 	__a       (    self	:Optional[Any])		->					Tuple:
												return

						def 	__a       (    self	:Dict)		->					List[str]:
												UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_lowercase)

						def 	__a       (    self	:Optional[int])		->					Union[str, Any]:
												UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*_lowercase)

						def 	__a       (    self	:Union[str, Any])		->					List[Any]:
												UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_backbone(*_lowercase)

						@unittest.skip(reason='''Dinat does not use inputs_embeds''')
						def 	__a       (    self	:int)		->					List[str]:
												pass

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

						def 	__a       (    self	:Any)		->					Tuple:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()

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

						def 	__a       (    self	:Optional[Any])		->					Dict:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()

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

																		UpperCAmelCase_     							=     ['''pixel_values''']
																		self.assertListEqual(arg_names[:1]   ,						_lowercase)

						def 	__a       (    self	:str)		->					Optional[Any]:
												self.skipTest('''Dinat\'s attention operation is handled entirely by NATTEN.''')

						def 	__a       (    self	:Optional[Any]   ,						_lowercase	:Dict   ,						_lowercase	:Tuple   ,						_lowercase	:Tuple   ,						_lowercase	:str)		->					Optional[Any]:
												UpperCAmelCase_     							=     model_class(_lowercase)
												model.to(_lowercase)
												model.eval()

												with torch.no_grad():
																		UpperCAmelCase_     							=     model(**self._prepare_for_class(_lowercase   ,						_lowercase))

												UpperCAmelCase_     							=     outputs.hidden_states

												UpperCAmelCase_     							=     getattr(
												    self.model_tester   ,						'''expected_num_hidden_layers'''   ,						len(self.model_tester.depths) + 1)
												self.assertEqual(len(_lowercase)   ,						_lowercase)

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

												UpperCAmelCase_     							=     image_size[0] // patch_size[0]
												UpperCAmelCase_     							=     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_     							=     outputs.reshaped_hidden_states
																		self.assertEqual(len(_lowercase)   ,						_lowercase)

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

						def 	__a       (    self	:str)		->					List[Any]:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()

												UpperCAmelCase_     							=     (
												    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_     							=     True
																		self.check_hidden_states_output(_lowercase   ,						_lowercase   ,						_lowercase   ,						_lowercase)

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

																		self.check_hidden_states_output(_lowercase   ,						_lowercase   ,						_lowercase   ,						_lowercase)

						@slow
						def 	__a       (    self	:int)		->					Tuple:
												for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		UpperCAmelCase_     							=     DinatModel.from_pretrained(_lowercase)
																		self.assertIsNotNone(_lowercase)




						def 	__a       (    self	:Any)		->					int:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()

												UpperCAmelCase_     							=     _config_zero_init(_lowercase)
												for model_class in self.all_model_classes:
																		UpperCAmelCase_     							=     model_class(config=_lowercase)
																		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				):

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




						@slow
						def 	__a       (    self	:str)		->					int:
												UpperCAmelCase_     							=     DinatForImageClassification.from_pretrained('''shi-labs/dinat-mini-in1k-224''').to(_lowercase)
												UpperCAmelCase_     							=     self.default_image_processor

												UpperCAmelCase_     							=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
												UpperCAmelCase_     							=     image_processor(images=_lowercase   ,						return_tensors='''pt''').to(_lowercase)

												# forward pass
												with torch.no_grad():
																		UpperCAmelCase_     							=     model(**_lowercase)

												# verify the logits
												UpperCAmelCase_     							=     torch.Size((1, 1000))
												self.assertEqual(outputs.logits.shape   ,						_lowercase)
												UpperCAmelCase_     							=     torch.tensor([-0.1_545, -0.7_667, 0.4_642]).to(_lowercase)
												self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,						_lowercase   ,						atol=1E-4))







@require_torch
@require_natten
class 							a_  (		unittest.TestCase					, _snake_case				):
						UpperCamelCase__      :						Tuple				       =(DinatBackbone,) if is_torch_available() else ()
						UpperCamelCase__      :						int				       =DinatConfig

						def 	__a       (    self	:Union[str, Any])		->					Dict:
												UpperCAmelCase_     							=     DinatModelTester(self)










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCamelCase_	       =   {"configuration_vit_hybrid": ["VIT_HYBRID_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTHybridConfig"]}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_	       =   [
							    "VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "ViTHybridForImageClassification",
							    "ViTHybridModel",
							    "ViTHybridPreTrainedModel",
							]

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_	       =   ["ViTHybridImageProcessor"]


if TYPE_CHECKING:
							from .configuration_vit_hybrid import VIT_HYBRID_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTHybridConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_vit_hybrid import (
														    VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST,
														    ViTHybridForImageClassification,
														    ViTHybridModel,
														    ViTHybridPreTrainedModel,
														)

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .image_processing_vit_hybrid import ViTHybridImageProcessor


else:
							import sys

							UpperCamelCase_	       =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





