





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




					def __init__(						self ,  lowerCAmelCase_ ,  lowerCAmelCase_=13 ,  lowerCAmelCase_=64 ,  lowerCAmelCase_=4 ,  lowerCAmelCase_=3 ,  lowerCAmelCase_=16 ,  lowerCAmelCase_=[1, 2, 1] ,  lowerCAmelCase_=[2, 4, 8] ,  lowerCAmelCase_=3 ,  lowerCAmelCase_=[[3], [1, 2], [1]] ,  lowerCAmelCase_=2.0 ,  lowerCAmelCase_=True ,  lowerCAmelCase_=0.0 ,  lowerCAmelCase_=0.0 ,  lowerCAmelCase_=0.1 ,  lowerCAmelCase_="gelu" ,  lowerCAmelCase_=True ,  lowerCAmelCase_=0.02 ,  lowerCAmelCase_=1E-5 ,  lowerCAmelCase_=True ,  lowerCAmelCase_=None ,  lowerCAmelCase_=True ,  lowerCAmelCase_=10 ,  lowerCAmelCase_=["stage1", "stage2"] ,  lowerCAmelCase_=[1, 2] ,  )						->							int:
										_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 		lowerCAmelCase	(						self     )						->							List[str]:
										_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 		lowerCAmelCase	(						self     )						->							List[Any]:
										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 		lowerCAmelCase	(						self ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_     )						->							int:
										_snake_case													= DinatModel(config=_lowerCamelCase     )
										model.to(_lowerCamelCase     )
										model.eval()
										_snake_case													= model(_lowerCamelCase     )

										_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 		lowerCAmelCase	(						self ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_     )						->							Any:
										_snake_case													= DinatForImageClassification(_lowerCamelCase     )
										model.to(_lowerCamelCase     )
										model.eval()
										_snake_case													= model(_lowerCamelCase ,  labels=_lowerCamelCase     )
										self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)     )

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

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




					def 		lowerCAmelCase	(						self ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_     )						->							Tuple:
										_snake_case													= DinatBackbone(config=_lowerCamelCase     )
										model.to(_lowerCamelCase     )
										model.eval()
										_snake_case													= model(_lowerCamelCase     )

										# 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=_lowerCamelCase     )
										model.to(_lowerCamelCase     )
										model.eval()
										_snake_case													= model(_lowerCamelCase     )

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





@require_natten
@require_torch
class 	UpperCamelCase_						(     __UpperCAmelCase							,     __UpperCAmelCase							,     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 		lowerCAmelCase	(						self     )						->							int:
										_snake_case													= DinatModelTester(self     )
										_snake_case													= ConfigTester(self ,  config_class=_lowerCamelCase ,  embed_dim=37     )




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




					def 		lowerCAmelCase	(						self     )						->							Union[str, Any]:
										_snake_case													= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowerCamelCase     )




					def 		lowerCAmelCase	(						self     )						->							List[Any]:
										_snake_case													= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase     )




					def 		lowerCAmelCase	(						self     )						->							str:
										_snake_case													= self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*_lowerCamelCase     )




					@unittest.skip(reason='Dinat does not use inputs_embeds'     )
					def 		lowerCAmelCase	(						self     )						->							str:
										pass




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




					def 		lowerCAmelCase	(						self     )						->							Union[str, Any]:
										_snake_case													= self.model_tester.prepare_config_and_inputs_for_common()

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




					def 		lowerCAmelCase	(						self     )						->							Dict:
										_snake_case													= self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															_snake_case													= model_class(_lowerCamelCase     )
															_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] ,  _lowerCamelCase     )




					def 		lowerCAmelCase	(						self     )						->							Any:
										self.skipTest('Dinat\'s attention operation is handled entirely by NATTEN.'     )




					def 		lowerCAmelCase	(						self ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_     )						->							List[Any]:
										_snake_case													= model_class(_lowerCamelCase     )
										model.to(_lowerCamelCase     )
										model.eval()

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

										_snake_case													= outputs.hidden_states

										_snake_case													= getattr(
										    self.model_tester ,  'expected_num_hidden_layers' ,  len(self.model_tester.depths     ) + 1     )
										self.assertEqual(len(_lowerCamelCase     ) ,  _lowerCamelCase     )

										# 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(_lowerCamelCase     ) ,  _lowerCamelCase     )

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




					def 		lowerCAmelCase	(						self     )						->							int:
										_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(_lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase     )

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

															self.check_hidden_states_output(_lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase     )




					@slow
					def 		lowerCAmelCase	(						self     )						->							int:
										for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_snake_case													= DinatModel.from_pretrained(_lowerCamelCase     )
															self.assertIsNotNone(_lowerCamelCase     )






					def 		lowerCAmelCase	(						self     )						->							Dict:
										_snake_case													= self.model_tester.prepare_config_and_inputs_for_common()

										_snake_case													= _config_zero_init(_lowerCamelCase     )
										for model_class in self.all_model_classes:
															_snake_case													= model_class(config=_lowerCamelCase     )
															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 	UpperCamelCase_						(     unittest.TestCase    ):




					@cached_property
					def 		lowerCAmelCase	(						self     )						->							Optional[Any]:
										return AutoImageProcessor.from_pretrained('shi-labs/dinat-mini-in1k-224'     ) if is_vision_available() else None






					@slow
					def 		lowerCAmelCase	(						self     )						->							Optional[Any]:
										_snake_case													= DinatForImageClassification.from_pretrained('shi-labs/dinat-mini-in1k-224'     ).to(_lowerCamelCase     )
										_snake_case													= self.default_image_processor

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

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

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





@require_torch
@require_natten
class 	UpperCamelCase_						(     unittest.TestCase							,     __UpperCAmelCase    ):
					lowerCAmelCase_							=		(DinatBackbone,) if is_torch_available() else ()
					lowerCAmelCase_							=		DinatConfig




					def 		lowerCAmelCase	(						self     )						->							Dict:
										_snake_case													= DinatModelTester(self     )










"""simple docstring"""





from ctypes import c_float, sizeof
from enum import Enum
from typing import TYPE_CHECKING, Optional, Union


if TYPE_CHECKING:
    from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore





class 			snake_case		(   __UpperCAmelCase   ):
      lowerCamelCase__						= c_float

      @property
      def 						SCREAMING_SNAKE_CASE_			(			self   :Optional[Any]						):
       return sizeof(self.value						)







def 		lowerCAmelCase_	(  lowercase_   :							int ,      lowercase_   :							int ,      lowercase_   :							int = 0		):

 '''simple docstring'''






 if dimension <= 0:
  __SCREAMING_SNAKE_CASE :			str												=       fixed_dimension

 dimension -= num_token_to_add
 return dimension




def 		lowerCAmelCase_	(  lowercase_   :							int ,      lowercase_   :							ParameterFormat		):

 '''simple docstring'''






 return num_parameters * dtype.size






def 		lowerCAmelCase_	(  lowercase_   :							str		):

 '''simple docstring'''






 from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore

 try:
  return AutoProcessor.from_pretrained(lowercase_		)
 except (ValueError, OSError, KeyError):
  __SCREAMING_SNAKE_CASE							,      __SCREAMING_SNAKE_CASE :			int												=       None, None
  try:
   __SCREAMING_SNAKE_CASE :			Optional[Any]												=       AutoTokenizer.from_pretrained(lowercase_		)
  except (OSError, KeyError):
   pass
  try:
   __SCREAMING_SNAKE_CASE :			Optional[Any]												=       AutoFeatureExtractor.from_pretrained(lowercase_		)
  except (OSError, KeyError):
   pass

  if tokenizer is not None and feature_extractor is not None:
   raise ValueError(
       F'''Couldn\'t auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor.'''		)
  elif tokenizer is None and feature_extractor is None:
   return None
  elif tokenizer is not None:
   return tokenizer
  else:
   return feature_extractor

