


'''simple docstring'''







from math import pi






def 	lowercase (_A    ):







       """simple docstring"""







       return degree / (1_8_0 / pi)


if __name__ == "__main__":
       from doctest import testmod

       testmod()








import collections
import inspect
import unittest

from transformers import NatConfig
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 NatBackbone, NatForImageClassification, NatModel
     from transformers.models.nat.modeling_nat import NAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor



class 							_UpperCamelCase    :

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




              """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_      				=     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 lowercase       (						self:       Dict						)				->       Tuple:




              """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 lowercase       (						self:       Dict						)				->       List[str]:




              """simple docstring"""


              return NatConfig(
                  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    ,      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 lowercase       (						self:       int    ,      _SCREAMING_SNAKE_CASE:       Optional[int]    ,      _SCREAMING_SNAKE_CASE:       Tuple    ,      _SCREAMING_SNAKE_CASE:       Any						)				->       int:




              """simple docstring"""


              UpperCamelCase_      				=     NatModel(config=_SCREAMING_SNAKE_CASE						)
              model.to(_SCREAMING_SNAKE_CASE						)
              model.eval()
              UpperCamelCase_      				=     model(_SCREAMING_SNAKE_CASE						)

              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 lowercase       (						self:       int    ,      _SCREAMING_SNAKE_CASE:       List[str]    ,      _SCREAMING_SNAKE_CASE:       Union[str, Any]    ,      _SCREAMING_SNAKE_CASE:       int						)				->       List[str]:




              """simple docstring"""


              UpperCamelCase_      				=     NatForImageClassification(_SCREAMING_SNAKE_CASE						)
              model.to(_SCREAMING_SNAKE_CASE						)
              model.eval()
              UpperCamelCase_      				=     model(_SCREAMING_SNAKE_CASE    ,      labels=_SCREAMING_SNAKE_CASE						)
              self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_labels)						)

              # test greyscale images
              UpperCamelCase_      				=     1
              UpperCamelCase_      				=     NatForImageClassification(_SCREAMING_SNAKE_CASE						)
              model.to(_SCREAMING_SNAKE_CASE						)
              model.eval()

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

       def lowercase       (						self:       List[Any]    ,      _SCREAMING_SNAKE_CASE:       str    ,      _SCREAMING_SNAKE_CASE:       Optional[Any]    ,      _SCREAMING_SNAKE_CASE:       str						)				->       Optional[int]:




              """simple docstring"""


              UpperCamelCase_      				=     NatBackbone(config=_SCREAMING_SNAKE_CASE						)
              model.to(_SCREAMING_SNAKE_CASE						)
              model.eval()
              UpperCamelCase_      				=     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_      				=     None
              UpperCamelCase_      				=     NatBackbone(config=_SCREAMING_SNAKE_CASE						)
              model.to(_SCREAMING_SNAKE_CASE						)
              model.eval()
              UpperCamelCase_      				=     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 lowercase       (						self:       Optional[Any]						)				->       Tuple:




              """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 							_UpperCamelCase    (		lowerCAmelCase_     ,  lowerCAmelCase_     ,  unittest.TestCase   ):
       _UpperCamelCase :    List[str]   			=      (
           (
               NatModel,
               NatForImageClassification,
               NatBackbone,
           )
           if is_torch_available()
           else ()
       )
       _UpperCamelCase :    List[str]   			=      (
           {'''feature-extraction''': NatModel, '''image-classification''': NatForImageClassification}
           if is_torch_available()
           else {}
       )
       _UpperCamelCase :    Any   			=      False

       _UpperCamelCase :    Tuple   			=      False
       _UpperCamelCase :    str   			=      False
       _UpperCamelCase :    Any   			=      False
       _UpperCamelCase :    int   			=      False

       def lowercase       (						self:       Tuple						)				->       Dict:




              """simple docstring"""


              UpperCamelCase_      				=     NatModelTester(self						)
              UpperCamelCase_      				=     ConfigTester(self    ,      config_class=_SCREAMING_SNAKE_CASE    ,      embed_dim=37						)

       def lowercase       (						self:       Tuple						)				->       Optional[int]:




              """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 lowercase       (						self:       Tuple						)				->       Dict:




              """simple docstring"""


              return

       def lowercase       (						self:       Optional[int]						)				->       Any:




              """simple docstring"""


              UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE						)

       def lowercase       (						self:       int						)				->       Optional[Any]:




              """simple docstring"""


              UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE						)

       def lowercase       (						self:       Dict						)				->       Optional[Any]:




              """simple docstring"""


              UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_backbone(*_SCREAMING_SNAKE_CASE						)

       @unittest.skip(reason="Nat does not use inputs_embeds"						)
       def lowercase       (						self:       Union[str, Any]						)				->       str:




              """simple docstring"""


              pass

       @unittest.skip(reason="Nat does not use feedforward chunking"						)
       def lowercase       (						self:       Optional[Any]						)				->       Any:




              """simple docstring"""


              pass

       def lowercase       (						self:       List[str]						)				->       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(_SCREAMING_SNAKE_CASE						)
                     self.assertIsInstance(model.get_input_embeddings()    ,      (nn.Module)						)
                     UpperCamelCase_      				=     model.get_output_embeddings()
                     self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE    ,      nn.Linear						)						)

       def lowercase       (						self:       List[str]						)				->       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(_SCREAMING_SNAKE_CASE						)
                     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]    ,      _SCREAMING_SNAKE_CASE						)

       def lowercase       (						self:       int						)				->       List[Any]:




              """simple docstring"""


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

       def lowercase       (						self:       Any    ,      _SCREAMING_SNAKE_CASE:       Any    ,      _SCREAMING_SNAKE_CASE:       int    ,      _SCREAMING_SNAKE_CASE:       Optional[Any]    ,      _SCREAMING_SNAKE_CASE:       Tuple						)				->       Optional[Any]:




              """simple docstring"""


              UpperCamelCase_      				=     model_class(_SCREAMING_SNAKE_CASE						)
              model.to(_SCREAMING_SNAKE_CASE						)
              model.eval()

              with torch.no_grad():
                     UpperCamelCase_      				=     model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,      _SCREAMING_SNAKE_CASE						)						)

              UpperCamelCase_      				=     outputs.hidden_states

              UpperCamelCase_      				=     getattr(
                  self.model_tester    ,      "expected_num_hidden_layers"    ,      len(self.model_tester.depths						) + 1						)
              self.assertEqual(len(_SCREAMING_SNAKE_CASE						)    ,      _SCREAMING_SNAKE_CASE						)

              # Nat 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__ != "NatBackbone":
                     UpperCamelCase_      				=     outputs.reshaped_hidden_states
                     self.assertEqual(len(_SCREAMING_SNAKE_CASE						)    ,      _SCREAMING_SNAKE_CASE						)

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




              """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(_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_      				=     True

                     self.check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,      _SCREAMING_SNAKE_CASE    ,      _SCREAMING_SNAKE_CASE    ,      _SCREAMING_SNAKE_CASE						)

       @slow
       def lowercase       (						self:       Union[str, Any]						)				->       Optional[Any]:




              """simple docstring"""


              for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     UpperCamelCase_      				=     NatModel.from_pretrained(_SCREAMING_SNAKE_CASE						)
                     self.assertIsNotNone(_SCREAMING_SNAKE_CASE						)



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




              """simple docstring"""


              UpperCamelCase_				,       UpperCamelCase_      				=     self.model_tester.prepare_config_and_inputs_for_common()

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

       @cached_property
       def lowercase       (						self:       Tuple						)				->       str:




              """simple docstring"""


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



       @slow
       def lowercase       (						self:       Tuple						)				->       Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_      				=     NatForImageClassification.from_pretrained("shi-labs/nat-mini-in1k-224"						).to(_SCREAMING_SNAKE_CASE						)
              UpperCamelCase_      				=     self.default_image_processor

              UpperCamelCase_      				=     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
              UpperCamelCase_      				=     image_processor(images=_SCREAMING_SNAKE_CASE    ,      return_tensors="pt"						).to(_SCREAMING_SNAKE_CASE						)

              # forward pass
              with torch.no_grad():
                     UpperCamelCase_      				=     model(**_SCREAMING_SNAKE_CASE						)

              # verify the logits
              UpperCamelCase_      				=     torch.Size((1, 1000)						)
              self.assertEqual(outputs.logits.shape    ,      _SCREAMING_SNAKE_CASE						)
              UpperCamelCase_      				=     torch.tensor([0.38_05, -0.86_76, -0.39_12]						).to(_SCREAMING_SNAKE_CASE						)
              self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,      _SCREAMING_SNAKE_CASE    ,      atol=1e-4						)						)



@require_torch
@require_natten
class 							_UpperCamelCase    (		unittest.TestCase     ,  lowerCAmelCase_   ):
       _UpperCamelCase :    Any   			=      (NatBackbone,) if is_torch_available() else ()
       _UpperCamelCase :    int   			=      NatConfig

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




              """simple docstring"""


              UpperCamelCase_      				=     NatModelTester(self						)

