




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  __lowerCAmelCase							:






       def __init__( self:       Union[str, Any]							,       _lowerCAmelCase:       int							,       _lowerCAmelCase:       Optional[Any]=13							,       _lowerCAmelCase:       str=64							,       _lowerCAmelCase:       Optional[int]=4							,       _lowerCAmelCase:       List[Any]=3							,       _lowerCAmelCase:       Tuple=16							,       _lowerCAmelCase:       int=[1, 2, 1]							,       _lowerCAmelCase:       str=[2, 4, 8]							,       _lowerCAmelCase:       Tuple=3							,       _lowerCAmelCase:       List[str]=2.0							,       _lowerCAmelCase:       Dict=True							,       _lowerCAmelCase:       Union[str, Any]=0.0							,       _lowerCAmelCase:       int=0.0							,       _lowerCAmelCase:       Union[str, Any]=0.1							,       _lowerCAmelCase:       Tuple="gelu"							,       _lowerCAmelCase:       Dict=True							,       _lowerCAmelCase:       int=0.02							,       _lowerCAmelCase:       List[Any]=1e-5							,       _lowerCAmelCase:       str=True							,       _lowerCAmelCase:       Union[str, Any]=None							,       _lowerCAmelCase:       Optional[Any]=True							,       _lowerCAmelCase:       str=10							,       _lowerCAmelCase:       str=["stage1", "stage2"]							,       _lowerCAmelCase:       List[str]=[1, 2]							,       ):
         lowercase     :str   						=    parent
         lowercase     :Tuple   						=    batch_size
         lowercase     :List[Any]   						=    image_size
         lowercase     :Optional[int]   						=    patch_size
         lowercase     :List[str]   						=    num_channels
         lowercase     :Union[str, Any]   						=    embed_dim
         lowercase     :Dict   						=    depths
         lowercase     :Tuple   						=    num_heads
         lowercase     :Union[str, Any]   						=    kernel_size
         lowercase     :Optional[int]   						=    mlp_ratio
         lowercase     :str   						=    qkv_bias
         lowercase     :List[Any]   						=    hidden_dropout_prob
         lowercase     :List[str]   						=    attention_probs_dropout_prob
         lowercase     :Dict   						=    drop_path_rate
         lowercase     :Union[str, Any]   						=    hidden_act
         lowercase     :List[Any]   						=    patch_norm
         lowercase     :List[str]   						=    layer_norm_eps
         lowercase     :Union[str, Any]   						=    initializer_range
         lowercase     :Optional[int]   						=    is_training
         lowercase     :int   						=    scope
         lowercase     :Optional[int]   						=    use_labels
         lowercase     :List[str]   						=    num_labels
         lowercase     :Any   						=    out_features
         lowercase     :Tuple   						=    out_indices






       def        SCREAMING_SNAKE_CASE     ( self:       Optional[int]					):
         lowercase     :Optional[Any]   						=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

         lowercase     :Optional[Any]   						=    self.get_config()

         return config, pixel_values, labels






       def        SCREAMING_SNAKE_CASE     ( self:       int					):
         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        SCREAMING_SNAKE_CASE     ( self:       str							,       _lowerCAmelCase:       Optional[Any]							,       _lowerCAmelCase:       List[str]							,       _lowerCAmelCase:       Dict					):
         lowercase     :List[Any]   						=    NatModel(config=_lowerCAmelCase					)
         model.to(_lowerCAmelCase					)
         model.eval()
         lowercase     :List[str]   						=    model(_lowerCAmelCase					)

         lowercase     :List[Any]   						=    (config.image_size // config.patch_size) // (2 ** (len(config.depths					) - 1))
         lowercase     :Optional[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        SCREAMING_SNAKE_CASE     ( self:       int							,       _lowerCAmelCase:       Tuple							,       _lowerCAmelCase:       int							,       _lowerCAmelCase:       Optional[Any]					):
         lowercase     :List[Any]   						=    NatForImageClassification(_lowerCAmelCase					)
         model.to(_lowerCAmelCase					)
         model.eval()
         lowercase     :Dict   						=    model(_lowerCAmelCase							,       labels=_lowerCAmelCase					)
         self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.num_labels)					)

         # test greyscale images
         lowercase     :Union[str, Any]   						=    1
         lowercase     :List[str]   						=    NatForImageClassification(_lowerCAmelCase					)
         model.to(_lowerCAmelCase					)
         model.eval()

         lowercase     :List[Any]   						=    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
         lowercase     :Dict   						=    model(_lowerCAmelCase					)
         self.parent.assertEqual(result.logits.shape							,       (self.batch_size, self.num_labels)					)






       def        SCREAMING_SNAKE_CASE     ( self:       Union[str, Any]							,       _lowerCAmelCase:       Dict							,       _lowerCAmelCase:       Optional[int]							,       _lowerCAmelCase:       str					):
         lowercase     :Any   						=    NatBackbone(config=_lowerCAmelCase					)
         model.to(_lowerCAmelCase					)
         model.eval()
         lowercase     :List[Any]   						=    model(_lowerCAmelCase					)

         # 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
         lowercase     :int   						=    None
         lowercase     :List[str]   						=    NatBackbone(config=_lowerCAmelCase					)
         model.to(_lowerCAmelCase					)
         model.eval()
         lowercase     :Union[str, Any]   						=    model(_lowerCAmelCase					)

         # 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        SCREAMING_SNAKE_CASE     ( self:       Optional[Any]					):
         lowercase     :Tuple   						=    self.prepare_config_and_inputs()
         lowercase						,     lowercase						,     lowercase     :Optional[int]   						=    config_and_inputs
         lowercase     :Optional[int]   						=    {"pixel_values": pixel_values}
         return config, inputs_dict







@require_natten
@require_torch
class  __lowerCAmelCase							(				lowerCAmelCase   ,			lowerCAmelCase   ,			unittest.TestCase):
       _a			       =    (
           (
               NatModel,
               NatForImageClassification,
               NatBackbone,
           )
           if is_torch_available()
           else ()
       )
       _a			       =    (
           {'''feature-extraction''': NatModel, '''image-classification''': NatForImageClassification}
           if is_torch_available()
           else {}
       )
       _a			       =    False

       _a			       =    False
       _a			       =    False
       _a			       =    False
       _a			       =    False






       def        SCREAMING_SNAKE_CASE     ( self:       Union[str, Any]					):
         lowercase     :List[Any]   						=    NatModelTester(self					)
         lowercase     :Union[str, Any]   						=    ConfigTester(self							,       config_class=_lowerCAmelCase							,       embed_dim=37					)






       def        SCREAMING_SNAKE_CASE     ( self:       Tuple					):
         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        SCREAMING_SNAKE_CASE     ( self:       int					):
         return






       def        SCREAMING_SNAKE_CASE     ( self:       Optional[Any]					):
         lowercase     :List[Any]   						=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowerCAmelCase					)






       def        SCREAMING_SNAKE_CASE     ( self:       Optional[Any]					):
         lowercase     :Dict   						=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase					)






       def        SCREAMING_SNAKE_CASE     ( self:       Optional[Any]					):
         lowercase     :Optional[int]   						=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*_lowerCAmelCase					)






       @unittest.skip(reason="Nat does not use inputs_embeds"					)
       def        SCREAMING_SNAKE_CASE     ( self:       Dict					):
         pass






       @unittest.skip(reason="Nat does not use feedforward chunking"					)
       def        SCREAMING_SNAKE_CASE     ( self:       str					):
         pass






       def        SCREAMING_SNAKE_CASE     ( self:       Any					):
         lowercase						,     lowercase     :Dict   						=    self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           lowercase     :int   						=    model_class(_lowerCAmelCase					)
           self.assertIsInstance(model.get_input_embeddings()							,       (nn.Module)					)
           lowercase     :Union[str, Any]   						=    model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(_lowerCAmelCase							,       nn.Linear					)					)






       def        SCREAMING_SNAKE_CASE     ( self:       Optional[int]					):
         lowercase						,     lowercase     :Union[str, Any]   						=    self.model_tester.prepare_config_and_inputs_for_common()

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

           lowercase     :Union[str, Any]   						=    ["pixel_values"]
           self.assertListEqual(arg_names[:1]							,       _lowerCAmelCase					)






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






       def        SCREAMING_SNAKE_CASE     ( self:       Any							,       _lowerCAmelCase:       str							,       _lowerCAmelCase:       Dict							,       _lowerCAmelCase:       Any							,       _lowerCAmelCase:       Union[str, Any]					):
         lowercase     :int   						=    model_class(_lowerCAmelCase					)
         model.to(_lowerCAmelCase					)
         model.eval()

         with torch.no_grad():
           lowercase     :Optional[int]   						=    model(**self._prepare_for_class(_lowerCAmelCase							,       _lowerCAmelCase					)					)

         lowercase     :int   						=    outputs.hidden_states

         lowercase     :int   						=    getattr(
             self.model_tester							,       "expected_num_hidden_layers"							,       len(self.model_tester.depths					) + 1					)
         self.assertEqual(len(_lowerCAmelCase					)							,       _lowerCAmelCase					)

         # Nat has a different seq_length
         lowercase     :List[Any]   						=    (
             config.patch_size
             if isinstance(config.patch_size							,       collections.abc.Iterable					)
             else (config.patch_size, config.patch_size)
         )

         lowercase     :Dict   						=    image_size[0] // patch_size[0]
         lowercase     :Dict   						=    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":
           lowercase     :str   						=    outputs.reshaped_hidden_states
           self.assertEqual(len(_lowerCAmelCase					)							,       _lowerCAmelCase					)

           lowercase						,     lowercase						,     lowercase						,     lowercase     :str   						=    reshaped_hidden_states[0].shape
           lowercase     :int   						=    (
               reshaped_hidden_states[0].view(_lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase					).permute(0							,       2							,       3							,       1					)
           )
           self.assertListEqual(
               list(reshaped_hidden_states.shape[-3:]					)							,       [height, width, self.model_tester.embed_dim]							,       )






       def        SCREAMING_SNAKE_CASE     ( self:       Union[str, Any]					):
         lowercase						,     lowercase     :int   						=    self.model_tester.prepare_config_and_inputs_for_common()

         lowercase     :Optional[Any]   						=    (
             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:
           lowercase     :Tuple   						=    True
           self.check_hidden_states_output(_lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase					)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           lowercase     :List[Any]   						=    True

           self.check_hidden_states_output(_lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase					)






       @slow
       def        SCREAMING_SNAKE_CASE     ( self:       List[Any]					):
         for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           lowercase     :List[Any]   						=    NatModel.from_pretrained(_lowerCAmelCase					)
           self.assertIsNotNone(_lowerCAmelCase					)






       def        SCREAMING_SNAKE_CASE     ( self:       Optional[Any]					):
         lowercase						,     lowercase     :Dict   						=    self.model_tester.prepare_config_and_inputs_for_common()

         lowercase     :Union[str, Any]   						=    _config_zero_init(_lowerCAmelCase					)
         for model_class in self.all_model_classes:
           lowercase     :Optional[Any]   						=    model_class(config=_lowerCAmelCase					)
           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        SCREAMING_SNAKE_CASE     ( self:       str					):
         return AutoImageProcessor.from_pretrained("shi-labs/nat-mini-in1k-224"					) if is_vision_available() else None






       @slow
       def        SCREAMING_SNAKE_CASE     ( self:       Optional[Any]					):
         lowercase     :Optional[int]   						=    NatForImageClassification.from_pretrained("shi-labs/nat-mini-in1k-224"					).to(_lowerCAmelCase					)
         lowercase     :str   						=    self.default_image_processor

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

         # forward pass
         with torch.no_grad():
           lowercase     :Any   						=    model(**_lowerCAmelCase					)

         # verify the logits
         lowercase     :Tuple   						=    torch.Size((1, 10_00)					)
         self.assertEqual(outputs.logits.shape							,       _lowerCAmelCase					)
         lowercase     :Optional[Any]   						=    torch.tensor([0.38_05, -0.86_76, -0.39_12]					).to(_lowerCAmelCase					)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]							,       _lowerCAmelCase							,       atol=1e-4					)					)







@require_torch
@require_natten
class  __lowerCAmelCase							(				unittest.TestCase   ,			lowerCAmelCase):
       _a			       =    (NatBackbone,) if is_torch_available() else ()
       _a			       =    NatConfig






       def        SCREAMING_SNAKE_CASE     ( self:       int					):
         lowercase     :Optional[Any]   						=    NatModelTester(self					)









import decimal



def    UpperCAmelCase__	(  ):
  lowercase     :int   						=    0
  lowercase     :str   						=    decimal.Context(prec=105 )
  for i in range(2,      100 ):
    lowercase     :int   						=    decimal.Decimal(lowerCamelCase )
    lowercase     :str   						=    number.sqrt(lowerCamelCase )
    if len(str(lowerCamelCase ) ) > 1:
      answer += int(str(lowerCamelCase )[0] )
      lowercase     :int   						=    str(lowerCamelCase )[2:101]
      answer += sum(int(lowerCamelCase ) for x in sqrt_number_str )
  return answer


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     print(f'''{solution() = }''')



