"""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 		_lowercase :



						"""simple docstring"""




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



													__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   UpperCAmelCase_ (				self							:    Optional[int]				)				->				str:
													'''simple docstring'''



													__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   UpperCAmelCase_ (				self							:    Union[str, Any]				)				->				Dict:
													'''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   UpperCAmelCase_ (				self							:    Union[str, Any]     , UpperCamelCase__							:    int     , UpperCamelCase__							:    Any     , UpperCamelCase__							:    List[str]				)				->				Optional[Any]:
													'''simple docstring'''



													__UpperCamelCase							=DinatModel(config=__UpperCAmelCase				)
													model.to(__UpperCAmelCase				)
													model.eval()
													__UpperCamelCase							=model(__UpperCAmelCase				)

													__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   UpperCAmelCase_ (				self							:    Optional[Any]     , UpperCamelCase__							:    Union[str, Any]     , UpperCamelCase__							:    Optional[int]     , UpperCamelCase__							:    int				)				->				Optional[int]:
													'''simple docstring'''



													__UpperCamelCase							=DinatForImageClassification(__UpperCAmelCase				)
													model.to(__UpperCAmelCase				)
													model.eval()
													__UpperCamelCase							=model(__UpperCAmelCase     , labels=__UpperCAmelCase				)
													self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.num_labels)				)

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

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





						def   UpperCAmelCase_ (				self							:    Optional[Any]     , UpperCamelCase__							:    str     , UpperCamelCase__							:    Optional[int]     , UpperCamelCase__							:    int				)				->				int:
													'''simple docstring'''



													__UpperCamelCase							=DinatBackbone(config=__UpperCAmelCase				)
													model.to(__UpperCAmelCase				)
													model.eval()
													__UpperCamelCase							=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
													__UpperCamelCase							=None
													__UpperCamelCase							=DinatBackbone(config=__UpperCAmelCase				)
													model.to(__UpperCAmelCase				)
													model.eval()
													__UpperCamelCase							=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   UpperCAmelCase_ (				self							:    int				)				->				Dict:
													'''simple docstring'''



													__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 		_lowercase (						SCREAMING_SNAKE_CASE_					,					SCREAMING_SNAKE_CASE_					,					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   UpperCAmelCase_ (				self							:    List[str]				)				->				List[str]:
													'''simple docstring'''



													__UpperCamelCase							=DinatModelTester(self				)
													__UpperCamelCase							=ConfigTester(self     , config_class=__UpperCAmelCase     , embed_dim=37				)





						def   UpperCAmelCase_ (				self							:    Dict				)				->				Tuple:
													'''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   UpperCAmelCase_ (				self							:    Tuple				)				->				Dict:
													'''simple docstring'''



													return





						def   UpperCAmelCase_ (				self							:    int				)				->				Any:
													'''simple docstring'''



													__UpperCamelCase							=self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*__UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    Optional[Any]				)				->				List[Any]:
													'''simple docstring'''



													__UpperCamelCase							=self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    int				)				->				Tuple:
													'''simple docstring'''



													__UpperCamelCase							=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   UpperCAmelCase_ (				self							:    Dict				)				->				List[Any]:
													'''simple docstring'''



													pass





						@unittest.skip(reason='''Dinat does not use feedforward chunking'''				)
						def   UpperCAmelCase_ (				self							:    str				)				->				Optional[int]:
													'''simple docstring'''



													pass





						def   UpperCAmelCase_ (				self							:    List[Any]				)				->				Optional[int]:
													'''simple docstring'''



													__UpperCamelCase	,      __UpperCamelCase							=self.model_tester.prepare_config_and_inputs_for_common()

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





						def   UpperCAmelCase_ (				self							:    Optional[Any]				)				->				Tuple:
													'''simple docstring'''



													__UpperCamelCase	,      __UpperCamelCase							=self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				__UpperCamelCase							=model_class(__UpperCAmelCase				)
																				__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]     , __UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    str				)				->				int:
													'''simple docstring'''



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





						def   UpperCAmelCase_ (				self							:    Any     , UpperCamelCase__							:    List[Any]     , UpperCamelCase__							:    Tuple     , UpperCamelCase__							:    Optional[int]     , UpperCamelCase__							:    Dict				)				->				Optional[Any]:
													'''simple docstring'''



													__UpperCamelCase							=model_class(__UpperCAmelCase				)
													model.to(__UpperCAmelCase				)
													model.eval()

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

													__UpperCamelCase							=outputs.hidden_states

													__UpperCamelCase							=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
													__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(__UpperCAmelCase				)     , __UpperCAmelCase				)

																				__UpperCamelCase	,      __UpperCamelCase	,      __UpperCamelCase	,      __UpperCamelCase							=reshaped_hidden_states[0].shape
																				__UpperCamelCase							=(
																				    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   UpperCAmelCase_ (				self							:    Optional[Any]				)				->				Dict:
													'''simple docstring'''



													__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(__UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase				)

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

																				self.check_hidden_states_output(__UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase				)





						@slow
						def   UpperCAmelCase_ (				self							:    str				)				->				List[str]:
													'''simple docstring'''



													for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__UpperCamelCase							=DinatModel.from_pretrained(__UpperCAmelCase				)
																				self.assertIsNotNone(__UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    Optional[int]				)				->				int:
													'''simple docstring'''



													__UpperCamelCase	,      __UpperCamelCase							=self.model_tester.prepare_config_and_inputs_for_common()

													__UpperCamelCase							=_config_zero_init(__UpperCAmelCase				)
													for model_class in self.all_model_classes:
																				__UpperCamelCase							=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 		_lowercase (						unittest.TestCase      ):



						"""simple docstring"""




						@cached_property
						def   UpperCAmelCase_ (				self							:    int				)				->				Any:
													'''simple docstring'''



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





						@slow
						def   UpperCAmelCase_ (				self							:    Optional[int]				)				->				str:
													'''simple docstring'''



													__UpperCamelCase							=DinatForImageClassification.from_pretrained('''shi-labs/dinat-mini-in1k-224'''				).to(__UpperCAmelCase				)
													__UpperCamelCase							=self.default_image_processor

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

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

													# verify the logits
													__UpperCamelCase							=torch.Size((1, 1000)				)
													self.assertEqual(outputs.logits.shape     , __UpperCAmelCase				)
													__UpperCamelCase							=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 		_lowercase (						unittest.TestCase					,					SCREAMING_SNAKE_CASE_      ):



						"""simple docstring"""




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





						def   UpperCAmelCase_ (				self							:    List[Any]				)				->				Union[str, Any]:
													'''simple docstring'''



													__UpperCamelCase							=DinatModelTester(self				)





"""simple docstring"""






from typing import TYPE_CHECKING

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


UpperCamelCase_						   =   {
    'configuration_mobilevitv2': [
        'MOBILEVITV2_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'MobileViTV2Config',
        'MobileViTV2OnnxConfig',
    ],
}


try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase_						   =   [
          'MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST',
          'MobileViTV2ForImageClassification',
          'MobileViTV2ForSemanticSegmentation',
          'MobileViTV2Model',
          'MobileViTV2PreTrainedModel',
      ]

if TYPE_CHECKING:
      from .configuration_mobilevitva import (
          MOBILEVITV2_PRETRAINED_CONFIG_ARCHIVE_MAP,
          MobileViTVaConfig,
          MobileViTVaOnnxConfig,
      )

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_mobilevitva import (
                MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
                MobileViTVaForImageClassification,
                MobileViTVaForSemanticSegmentation,
                MobileViTVaModel,
                MobileViTVaPreTrainedModel,
            )

else:
      import sys

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