

'''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 	SCREAMING_SNAKE_CASE__			:




    def __init__(					self				,     lowercase__				,     lowercase__=13				,     lowercase__=64				,     lowercase__=4				,     lowercase__=3				,     lowercase__=16				,     lowercase__=[1, 2, 1]				,     lowercase__=[2, 4, 8]				,     lowercase__=3				,     lowercase__=[[3], [1, 2], [1]]				,     lowercase__=2.0				,     lowercase__=True				,     lowercase__=0.0				,     lowercase__=0.0				,     lowercase__=0.1				,     lowercase__="gelu"				,     lowercase__=True				,     lowercase__=0.02				,     lowercase__=1e-5				,     lowercase__=True				,     lowercase__=None				,     lowercase__=True				,     lowercase__=10				,     lowercase__=["stage1", "stage2"]				,     lowercase__=[1, 2]				,     ):






          """simple docstring"""






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




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Tuple     =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       None
          if self.use_labels:
                SCREAMING_SNAKE_CASE_      :			List[str]     =       ids_tensor([self.batch_size]				,     self.num_labels			)

          SCREAMING_SNAKE_CASE_      :			Tuple     =       self.get_config()

          return config, pixel_values, labels




    def   __lowerCamelCase      (					self			):






          """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   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       DinatModel(config=lowercase__			)
          model.to(lowercase__			)
          model.eval()
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       model(lowercase__			)

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






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       DinatForImageClassification(lowercase__			)
          model.to(lowercase__			)
          model.eval()
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       model(lowercase__				,     labels=lowercase__			)
          self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)			)

          # test greyscale images
          SCREAMING_SNAKE_CASE_      :			int     =       1
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       DinatForImageClassification(lowercase__			)
          model.to(lowercase__			)
          model.eval()

          SCREAMING_SNAKE_CASE_      :			Dict     =       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       model(lowercase__			)
          self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)			)




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			int     =       DinatBackbone(config=lowercase__			)
          model.to(lowercase__			)
          model.eval()
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       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
          SCREAMING_SNAKE_CASE_      :			List[str]     =       None
          SCREAMING_SNAKE_CASE_      :			Dict     =       DinatBackbone(config=lowercase__			)
          model.to(lowercase__			)
          model.eval()
          SCREAMING_SNAKE_CASE_      :			int     =       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   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       self.prepare_config_and_inputs()
          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			Any     =       config_and_inputs
          SCREAMING_SNAKE_CASE_      :			Any     =       {"pixel_values": pixel_values}
          return config, inputs_dict






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

    _A			    =							False
    _A			    =							False
    _A			    =							False
    _A			    =							False




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			List[str]     =       DinatModelTester(self			)
          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       ConfigTester(self				,     config_class=lowercase__				,     embed_dim=37			)




    def   __lowerCamelCase      (					self			):






          """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   __lowerCamelCase      (					self			):






          """simple docstring"""






          return




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase__			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Optional[int]     =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowercase__			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			str     =       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   __lowerCamelCase      (					self			):






          """simple docstring"""






          pass




    @unittest.skip(reason="Dinat does not use feedforward chunking"			)
    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          pass




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






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

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




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       model_class(lowercase__			)
                SCREAMING_SNAKE_CASE_      :			Optional[Any]     =       inspect.signature(model.forward			)
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                SCREAMING_SNAKE_CASE_      :			List[str]     =       [*signature.parameters.keys()]

                SCREAMING_SNAKE_CASE_      :			Optional[int]     =       ["pixel_values"]
                self.assertListEqual(arg_names[:1]				,     lowercase__			)




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






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




    def   __lowerCamelCase      (					self				,     lowercase__				,     lowercase__				,     lowercase__				,     lowercase__			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Any     =       model_class(lowercase__			)
          model.to(lowercase__			)
          model.eval()

          with torch.no_grad():
                SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       model(**self._prepare_for_class(lowercase__				,     lowercase__			)			)

          SCREAMING_SNAKE_CASE_      :			Tuple     =       outputs.hidden_states

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

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

                SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			Dict     =       reshaped_hidden_states[0].shape
                SCREAMING_SNAKE_CASE_      :			List[str]     =       (
                    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   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       self.model_tester.prepare_config_and_inputs_for_common()

          SCREAMING_SNAKE_CASE_      :			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:
                SCREAMING_SNAKE_CASE_      :			List[Any]     =       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"]
                SCREAMING_SNAKE_CASE_      :			Tuple     =       True

                self.check_hidden_states_output(lowercase__				,     lowercase__				,     lowercase__				,     lowercase__			)




    @slow
    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                SCREAMING_SNAKE_CASE_      :			List[str]     =       DinatModel.from_pretrained(lowercase__			)
                self.assertIsNotNone(lowercase__			)







    def   __lowerCamelCase      (					self			):






          """simple docstring"""






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

          SCREAMING_SNAKE_CASE_      :			Any     =       _config_zero_init(lowercase__			)
          for model_class in self.all_model_classes:
                SCREAMING_SNAKE_CASE_      :			str     =       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 	SCREAMING_SNAKE_CASE__			(				unittest.TestCase      ):




    @cached_property
    def   __lowerCamelCase      (					self			):






          """simple docstring"""






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







    @slow
    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			int     =       DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224"			).to(lowercase__			)
          SCREAMING_SNAKE_CASE_      :			str     =       self.default_image_processor

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

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

          # verify the logits
          SCREAMING_SNAKE_CASE_      :			Union[str, Any]     =       torch.Size((1, 1000)			)
          self.assertEqual(outputs.logits.shape				,     lowercase__			)
          SCREAMING_SNAKE_CASE_      :			Any     =       torch.tensor([-0.1545, -0.7667, 0.4642]			).to(lowercase__			)
          self.assertTrue(torch.allclose(outputs.logits[0, :3]				,     lowercase__				,     atol=1e-4			)			)






@require_torch
@require_natten
class 	SCREAMING_SNAKE_CASE__			(				unittest.TestCase,_UpperCAmelCase      ):
    _A			    =							(DinatBackbone,) if is_torch_available() else ()
    _A			    =							DinatConfig




    def   __lowerCamelCase      (					self			):






          """simple docstring"""






          SCREAMING_SNAKE_CASE_      :			Dict     =       DinatModelTester(self			)





from __future__ import annotations
def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__			,       SCREAMING_SNAKE_CASE__						):
 __lowerCamelCase					,     __lowerCamelCase		:							str							=						m - 1, 0
 while i >= 0 and j < n:
  if key == mat[i][j]:
   print(f'Key {key} found at row- {i + 1} column- {j + 1}'						)
   return
  if key < mat[i][j]:
   i -= 1
  else:
   j += 1
 print(f'Key {key} not found'						)
def       UpperCamelCase__     (  ):
 __lowerCamelCase		:							List[Any]							=						[[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
 __lowerCamelCase		:							int							=						int(input('Enter the element to be searched:'						)						)
 print(SCREAMING_SNAKE_CASE__						)
 search_in_a_sorted_matrix(SCREAMING_SNAKE_CASE__			,       len(SCREAMING_SNAKE_CASE__						)			,       len(mat[0]						)			,       SCREAMING_SNAKE_CASE__						)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()

