


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   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE=13   ,			__SCREAMING_SNAKE_CASE=64   ,			__SCREAMING_SNAKE_CASE=4   ,			__SCREAMING_SNAKE_CASE=3   ,			__SCREAMING_SNAKE_CASE=16   ,			__SCREAMING_SNAKE_CASE=[1, 2, 1]   ,			__SCREAMING_SNAKE_CASE=[2, 4, 8]   ,			__SCREAMING_SNAKE_CASE=3   ,			__SCREAMING_SNAKE_CASE=[[3], [1, 2], [1]]   ,			__SCREAMING_SNAKE_CASE=2.0   ,			__SCREAMING_SNAKE_CASE=True   ,			__SCREAMING_SNAKE_CASE=0.0   ,			__SCREAMING_SNAKE_CASE=0.0   ,			__SCREAMING_SNAKE_CASE=0.1   ,			__SCREAMING_SNAKE_CASE="gelu"   ,			__SCREAMING_SNAKE_CASE=True   ,			__SCREAMING_SNAKE_CASE=0.02   ,			__SCREAMING_SNAKE_CASE=1E-5   ,			__SCREAMING_SNAKE_CASE=True   ,			__SCREAMING_SNAKE_CASE=None   ,			__SCREAMING_SNAKE_CASE=True   ,			__SCREAMING_SNAKE_CASE=10   ,			__SCREAMING_SNAKE_CASE=["stage1", "stage2"]   ,			__SCREAMING_SNAKE_CASE=[1, 2]   ,			)					->						Optional[int]:







         """simple docstring"""







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




      def    UpperCAmelCase							(		self)					->						Optional[int]:







         """simple docstring"""







         UpperCamelCase__ :			Union[str, Any] 						=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

         UpperCamelCase__ :			List[str] 						=self.get_config()

         return config, pixel_values, labels




      def    UpperCAmelCase							(		self)					->						List[str]:







         """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   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						Optional[Any]:







         """simple docstring"""







         UpperCamelCase__ :			Dict 						=DinatModel(config=__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()
         UpperCamelCase__ :			Any 						=model(__SCREAMING_SNAKE_CASE)

         UpperCamelCase__ :			Optional[Any] 						=(config.image_size // config.patch_size) // (2 ** (len(config.depths) - 1))
         UpperCamelCase__ :			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    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						Any:







         """simple docstring"""







         UpperCamelCase__ :			Optional[Any] 						=DinatForImageClassification(__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()
         UpperCamelCase__ :			List[Any] 						=model(__SCREAMING_SNAKE_CASE   ,			labels=__SCREAMING_SNAKE_CASE)
         self.parent.assertEqual(result.logits.shape   ,			(self.batch_size, self.num_labels))

         # test greyscale images
         UpperCamelCase__ :			Any 						=1
         UpperCamelCase__ :			str 						=DinatForImageClassification(__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()

         UpperCamelCase__ :			str 						=floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
         UpperCamelCase__ :			Union[str, Any] 						=model(__SCREAMING_SNAKE_CASE)
         self.parent.assertEqual(result.logits.shape   ,			(self.batch_size, self.num_labels))




      def    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						Optional[Any]:







         """simple docstring"""







         UpperCamelCase__ :			Tuple 						=DinatBackbone(config=__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()
         UpperCamelCase__ :			Optional[int] 						=model(__SCREAMING_SNAKE_CASE)

         # 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__ :			Optional[int] 						=None
         UpperCamelCase__ :			Optional[int] 						=DinatBackbone(config=__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()
         UpperCamelCase__ :			List[str] 						=model(__SCREAMING_SNAKE_CASE)

         # 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)					->						Union[str, Any]:







         """simple docstring"""







         UpperCamelCase__ :			str 						=self.prepare_config_and_inputs()
         UpperCamelCase__						,	UpperCamelCase__						,	UpperCamelCase__ :			Any 						=config_and_inputs
         UpperCamelCase__ :			Any 						={"pixel_values": pixel_values}
         return config, inputs_dict




@require_natten
@require_torch
class 							lowercase__(						snake_case__			,							snake_case__			,							unittest.TestCase			):






      '''simple docstring'''







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

      snake_case__       =					False
      snake_case__       =					False
      snake_case__       =					False
      snake_case__       =					False




      def    UpperCAmelCase							(		self)					->						Dict:







         """simple docstring"""







         UpperCamelCase__ :			int 						=DinatModelTester(self)
         UpperCamelCase__ :			Any 						=ConfigTester(self   ,			config_class=__SCREAMING_SNAKE_CASE   ,			embed_dim=37)




      def    UpperCAmelCase							(		self)					->						List[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    UpperCAmelCase							(		self)					->						Optional[Any]:







         """simple docstring"""







         return




      def    UpperCAmelCase							(		self)					->						Optional[int]:







         """simple docstring"""







         UpperCamelCase__ :			Dict 						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						Dict:







         """simple docstring"""







         UpperCamelCase__ :			Tuple 						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						List[str]:







         """simple docstring"""







         UpperCamelCase__ :			List[str] 						=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*__SCREAMING_SNAKE_CASE)




      @unittest.skip(reason="Dinat does not use inputs_embeds")
      def    UpperCAmelCase							(		self)					->						Dict:







         """simple docstring"""







         pass




      @unittest.skip(reason="Dinat does not use feedforward chunking")
      def    UpperCAmelCase							(		self)					->						Any:







         """simple docstring"""







         pass




      def    UpperCAmelCase							(		self)					->						int:







         """simple docstring"""







         UpperCamelCase__						,	UpperCamelCase__ :			int 						=self.model_tester.prepare_config_and_inputs_for_common()

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




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







         """simple docstring"""







         UpperCamelCase__						,	UpperCamelCase__ :			List[Any] 						=self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCamelCase__ :			List[Any] 						=model_class(__SCREAMING_SNAKE_CASE)
            UpperCamelCase__ :			Union[str, Any] 						=inspect.signature(model.forward)
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            UpperCamelCase__ :			Tuple 						=[*signature.parameters.keys()]

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




      def    UpperCAmelCase							(		self)					->						Optional[Any]:







         """simple docstring"""







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




      def    UpperCAmelCase							(		self   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)					->						List[str]:







         """simple docstring"""







         UpperCamelCase__ :			Optional[int] 						=model_class(__SCREAMING_SNAKE_CASE)
         model.to(__SCREAMING_SNAKE_CASE)
         model.eval()

         with torch.no_grad():
            UpperCamelCase__ :			Dict 						=model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE))

         UpperCamelCase__ :			List[str] 						=outputs.hidden_states

         UpperCamelCase__ :			List[str] 						=getattr(
             self.model_tester   ,			"expected_num_hidden_layers"   ,			len(self.model_tester.depths) + 1)
         self.assertEqual(len(__SCREAMING_SNAKE_CASE)   ,			__SCREAMING_SNAKE_CASE)

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

         UpperCamelCase__ :			Dict 						=image_size[0] // patch_size[0]
         UpperCamelCase__ :			int 						=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__ :			Any 						=outputs.reshaped_hidden_states
            self.assertEqual(len(__SCREAMING_SNAKE_CASE)   ,			__SCREAMING_SNAKE_CASE)

            UpperCamelCase__						,	UpperCamelCase__						,	UpperCamelCase__						,	UpperCamelCase__ :			Union[str, Any] 						=reshaped_hidden_states[0].shape
            UpperCamelCase__ :			Optional[int] 						=(
                reshaped_hidden_states[0].view(__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE).permute(0   ,			2   ,			3   ,			1)
            )
            self.assertListEqual(
                list(reshaped_hidden_states.shape[-3:])   ,			[height, width, self.model_tester.embed_dim]   ,			)




      def    UpperCAmelCase							(		self)					->						Dict:







         """simple docstring"""







         UpperCamelCase__						,	UpperCamelCase__ :			List[Any] 						=self.model_tester.prepare_config_and_inputs_for_common()

         UpperCamelCase__ :			str 						=(
             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__ :			str 						=True
            self.check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)

            # check that output_hidden_states also work using config
            del inputs_dict["output_hidden_states"]
            UpperCamelCase__ :			Dict 						=True

            self.check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE)




      @slow
      def    UpperCAmelCase							(		self)					->						Optional[int]:







         """simple docstring"""







         for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCamelCase__ :			Any 						=DinatModel.from_pretrained(__SCREAMING_SNAKE_CASE)
            self.assertIsNotNone(__SCREAMING_SNAKE_CASE)




      def    UpperCAmelCase							(		self)					->						int:







         """simple docstring"""







         UpperCamelCase__						,	UpperCamelCase__ :			List[Any] 						=self.model_tester.prepare_config_and_inputs_for_common()

         UpperCamelCase__ :			str 						=_config_zero_init(__SCREAMING_SNAKE_CASE)
         for model_class in self.all_model_classes:
            UpperCamelCase__ :			Any 						=model_class(config=__SCREAMING_SNAKE_CASE)
            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)					->						Any:







         """simple docstring"""







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




      @slow
      def    UpperCAmelCase							(		self)					->						Any:







         """simple docstring"""







         UpperCamelCase__ :			str 						=DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224").to(__SCREAMING_SNAKE_CASE)
         UpperCamelCase__ :			Optional[Any] 						=self.default_image_processor

         UpperCamelCase__ :			Optional[int] 						=Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
         UpperCamelCase__ :			List[str] 						=image_processor(images=__SCREAMING_SNAKE_CASE   ,			return_tensors="pt").to(__SCREAMING_SNAKE_CASE)

         # forward pass
         with torch.no_grad():
            UpperCamelCase__ :			List[Any] 						=model(**__SCREAMING_SNAKE_CASE)

         # verify the logits
         UpperCamelCase__ :			Optional[Any] 						=torch.Size((1, 10_00))
         self.assertEqual(outputs.logits.shape   ,			__SCREAMING_SNAKE_CASE)
         UpperCamelCase__ :			Optional[Any] 						=torch.tensor([-0.15_45, -0.76_67, 0.46_42]).to(__SCREAMING_SNAKE_CASE)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,			__SCREAMING_SNAKE_CASE   ,			atol=1E-4))




@require_torch
@require_natten
class 							lowercase__(						unittest.TestCase			,							snake_case__			):






      '''simple docstring'''







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




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







         """simple docstring"""







         UpperCamelCase__ :			Optional[int] 						=DinatModelTester(self)





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCAmelCase      			=  {"""configuration_sew_d""": ["""SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SEWDConfig"""]}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __UpperCAmelCase      			=  [
         """SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """SEWDForCTC""",
         """SEWDForSequenceClassification""",
         """SEWDModel""",
         """SEWDPreTrainedModel""",
     ]

if TYPE_CHECKING:
     from .configuration_sew_d import SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWDConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_sew_d import (
              SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST,
              SEWDForCTC,
              SEWDForSequenceClassification,
              SEWDModel,
              SEWDPreTrainedModel,
          )


else:
     import sys

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

