




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


       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]			,     )					->     Dict:



            '''simple docstring'''




            __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[Any]:



            '''simple docstring'''




            __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     )					->     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 					lowerCAmelCase					(      self			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE     )					->     List[Any]:



            '''simple docstring'''




            __snake_case			    =     DinatModel(config=__SCREAMING_SNAKE_CASE     )
            model.to(__SCREAMING_SNAKE_CASE     )
            model.eval()
            __snake_case			    =     model(__SCREAMING_SNAKE_CASE     )

            __snake_case			    =     __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			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE     )					->     str:



            '''simple docstring'''




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

            # test greyscale images
            __snake_case			    =     1
            __snake_case			    =     DinatForImageClassification(__SCREAMING_SNAKE_CASE     )
            model.to(__SCREAMING_SNAKE_CASE     )
            model.eval()

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


       def 					lowerCAmelCase					(      self			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE     )					->     List[Any]:



            '''simple docstring'''




            __snake_case			    =     DinatBackbone(config=__SCREAMING_SNAKE_CASE     )
            model.to(__SCREAMING_SNAKE_CASE     )
            model.eval()
            __snake_case			    =     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
            __snake_case			    =     None
            __snake_case			    =     DinatBackbone(config=__SCREAMING_SNAKE_CASE     )
            model.to(__SCREAMING_SNAKE_CASE     )
            model.eval()
            __snake_case			    =     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 					lowerCAmelCase					(      self     )					->     str:



            '''simple docstring'''




            __snake_case			    =     self.prepare_config_and_inputs()
            __snake_case    ,			__snake_case    ,			__snake_case			    =     config_and_inputs
            __snake_case			    =     {'''pixel_values''': pixel_values}
            return config, inputs_dict





@require_natten
@require_torch
class 			lowerCAmelCase      (       __lowerCAmelCase ,      __lowerCAmelCase ,      unittest.TestCase):
       __lowercase     :					Any       				=	(
           (
               DinatModel,
               DinatForImageClassification,
               DinatBackbone,
           )
           if is_torch_available()
           else ()
       )
       __lowercase     :					Dict       				=	(
           {'''feature-extraction''': DinatModel, '''image-classification''': DinatForImageClassification}
           if is_torch_available()
           else {}
       )
       __lowercase     :					Tuple       				=	False

       __lowercase     :					Any       				=	False
       __lowercase     :					Tuple       				=	False
       __lowercase     :					Tuple       				=	False
       __lowercase     :					Union[str, Any]       				=	False


       def 					lowerCAmelCase					(      self     )					->     str:



            '''simple docstring'''




            __snake_case			    =     DinatModelTester(self     )
            __snake_case			    =     ConfigTester(self			,     config_class=__SCREAMING_SNAKE_CASE			,     embed_dim=37     )


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



            '''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     )					->     List[Any]:



            '''simple docstring'''




            return


       def 					lowerCAmelCase					(      self     )					->     Tuple:



            '''simple docstring'''




            __snake_case			    =     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE     )


       def 					lowerCAmelCase					(      self     )					->     Tuple:



            '''simple docstring'''




            __snake_case			    =     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE     )


       def 					lowerCAmelCase					(      self     )					->     Dict:



            '''simple docstring'''




            __snake_case			    =     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 					lowerCAmelCase					(      self     )					->     Optional[Any]:



            '''simple docstring'''




            pass


       @unittest.skip(reason='''Dinat does not use feedforward chunking'''     )
       def 					lowerCAmelCase					(      self     )					->     Tuple:



            '''simple docstring'''




            pass


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



            '''simple docstring'''




            __snake_case    ,			__snake_case			    =     self.model_tester.prepare_config_and_inputs_for_common()

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


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



            '''simple docstring'''




            __snake_case    ,			__snake_case			    =     self.model_tester.prepare_config_and_inputs_for_common()

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


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



            '''simple docstring'''




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


       def 					lowerCAmelCase					(      self			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE     )					->     List[Any]:



            '''simple docstring'''




            __snake_case			    =     model_class(__SCREAMING_SNAKE_CASE     )
            model.to(__SCREAMING_SNAKE_CASE     )
            model.eval()

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

            __snake_case			    =     outputs.hidden_states

            __snake_case			    =     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
            __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(__SCREAMING_SNAKE_CASE     )			,     __SCREAMING_SNAKE_CASE     )

                 __snake_case    ,			__snake_case    ,			__snake_case    ,			__snake_case			    =     reshaped_hidden_states[0].shape
                 __snake_case			    =     (
                     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 					lowerCAmelCase					(      self     )					->     Union[str, Any]:



            '''simple docstring'''




            __snake_case    ,			__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(__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"]
                 __snake_case			    =     True

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


       @slow
       def 					lowerCAmelCase					(      self     )					->     Dict:



            '''simple docstring'''




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




       def 					lowerCAmelCase					(      self     )					->     List[Any]:



            '''simple docstring'''




            __snake_case    ,			__snake_case			    =     self.model_tester.prepare_config_and_inputs_for_common()

            __snake_case			    =     _config_zero_init(__SCREAMING_SNAKE_CASE     )
            for model_class in self.all_model_classes:
                 __snake_case			    =     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 			lowerCAmelCase      (       unittest.TestCase):


       @cached_property
       def 					lowerCAmelCase					(      self     )					->     List[Any]:



            '''simple docstring'''




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




       @slow
       def 					lowerCAmelCase					(      self     )					->     int:



            '''simple docstring'''




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

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

            # forward pass
            with torch.no_grad():
                 __snake_case			    =     model(**__SCREAMING_SNAKE_CASE     )

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





@require_torch
@require_natten
class 			lowerCAmelCase      (       unittest.TestCase ,      __lowerCAmelCase):
       __lowercase     :					Union[str, Any]       				=	(DinatBackbone,) if is_torch_available() else ()
       __lowercase     :					str       				=	DinatConfig


       def 					lowerCAmelCase					(      self     )					->     List[Any]:



            '''simple docstring'''




            __snake_case			    =     DinatModelTester(self     )












'''simple docstring'''



def 	_UpperCamelCase       (_lowerCamelCase							:   list[list[int]]      ,		_lowerCamelCase							:   list[list[int]]		)->      list[list[int]]:




     '''simple docstring'''





     __snake_case			    =     []
     __snake_case			    =     len(_lowerCamelCase		)
     for i in range(_lowerCamelCase		):
          __snake_case			    =     []
          for j in range(_lowerCamelCase		):
               __snake_case			    =     0
               for k in range(_lowerCamelCase		):
                    __snake_case			    =     val + matrix_a[i][k] * matrix_b[k][j]
               list_a.append(_lowerCamelCase		)
          matrix_c.append(_lowerCamelCase		)
     return matrix_c







def 	_UpperCamelCase       (_lowerCamelCase							:   int		)->      list[list[int]]:




     '''simple docstring'''





     return [[int(row == column		) for column in range(_lowerCamelCase		)] for row in range(_lowerCamelCase		)]







def 	_UpperCamelCase       (_lowerCamelCase							:   int		)->      int:




     '''simple docstring'''





     if n <= 1:
          return n
     __snake_case			    =     identity(2		)
     __snake_case			    =     [[1, 1], [1, 0]]
     __snake_case			    =     n - 1
     while n > 0:
          if n % 2 == 1:
               __snake_case			    =     multiply(_lowerCamelCase      ,		_lowerCamelCase		)
          __snake_case			    =     multiply(_lowerCamelCase      ,		_lowerCamelCase		)
          __snake_case			    =     int(n / 2		)
     return res_matrix[0][0]







def 	_UpperCamelCase       (_lowerCamelCase							:   int		)->      int:




     '''simple docstring'''





     if n <= 1:
          return n
     __snake_case			    =     0
     __snake_case			    =     1
     for _ in range(2      ,		n + 1		):
          __snake_case    ,			__snake_case			    =     fiba, fiba + fiba
     return fiba







def 	_UpperCamelCase       ()->      None:




     '''simple docstring'''





     for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
          __snake_case			    =     int(''''''.join(c for c in ordinal if c in '''0123456789'''		)		)  # 1000th --> 1000
          print(
              f'''{ordinal} fibonacci number using matrix exponentiation is '''
              f'''{nth_fibonacci_matrix(_lowerCamelCase		)} and using bruteforce is '''
              f'''{nth_fibonacci_bruteforce(_lowerCamelCase		)}\n'''		)
     # from timeit import timeit
     # print(timeit("nth_fibonacci_matrix(1000000)",
     #              "from main import nth_fibonacci_matrix", number=5))
     # print(timeit("nth_fibonacci_bruteforce(1000000)",
     #              "from main import nth_fibonacci_bruteforce", number=5))
     # 2.3342058970001744
     # 57.256506615000035


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     main()






