


'''simple docstring'''
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 					_A						:



   '''simple docstring'''






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




   def   __lowerCAmelCase						(	self	:					List[Any]						)->	Optional[int]:
          snake_case__					:	str          =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

          snake_case__					:	List[Any]          =					None
          if self.use_labels:
                 snake_case__					:	Dict          =					ids_tensor([self.batch_size]					, self.num_labels						)

          snake_case__					:	List[Any]          =					self.get_config()

          return config, pixel_values, labels




   def   __lowerCAmelCase						(	self	:					Any						)->	Union[str, Any]:
          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   __lowerCAmelCase						(	self	:					List[Any]					, lowerCamelCase	:					Optional[Any]					, lowerCamelCase	:					List[Any]					, lowerCamelCase	:					Union[str, Any]						)->	Optional[int]:
          snake_case__					:	Union[str, Any]          =					NatModel(config=lowerCamelCase						)
          model.to(lowerCamelCase						)
          model.eval()
          snake_case__					:	str          =					model(lowerCamelCase						)

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

          # test greyscale images
          snake_case__					:	Dict          =					1
          snake_case__					:	Optional[int]          =					NatForImageClassification(lowerCamelCase						)
          model.to(lowerCamelCase						)
          model.eval()

          snake_case__					:	int          =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
          snake_case__					:	List[str]          =					model(lowerCamelCase						)
          self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.num_labels)						)




   def   __lowerCAmelCase						(	self	:					str					, lowerCamelCase	:					List[Any]					, lowerCamelCase	:					Dict					, lowerCamelCase	:					Dict						)->	int:
          snake_case__					:	List[str]          =					NatBackbone(config=lowerCamelCase						)
          model.to(lowerCamelCase						)
          model.eval()
          snake_case__					:	int          =					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
          snake_case__					:	Optional[Any]          =					None
          snake_case__					:	Optional[Any]          =					NatBackbone(config=lowerCamelCase						)
          model.to(lowerCamelCase						)
          model.eval()
          snake_case__					:	List[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   __lowerCAmelCase						(	self	:					Optional[Any]						)->	Dict:
          snake_case__					:	List[Any]          =					self.prepare_config_and_inputs()
          snake_case__       ,   snake_case__       ,   snake_case__					:	Tuple          =					config_and_inputs
          snake_case__					:	Optional[int]          =					{"""pixel_values""": pixel_values}
          return config, inputs_dict







@require_natten
@require_torch
class 					_A						(						UpperCamelCase    ,  UpperCamelCase    ,  unittest.TestCase							):



   '''simple docstring'''






   _lowercase    						= (
       (
           NatModel,
           NatForImageClassification,
           NatBackbone,
       )
       if is_torch_available()
       else ()
   )
   _lowercase    						= (
       {'feature-extraction': NatModel, 'image-classification': NatForImageClassification}
       if is_torch_available()
       else {}
   )
   _lowercase    						= False

   _lowercase    						= False
   _lowercase    						= False
   _lowercase    						= False
   _lowercase    						= False




   def   __lowerCAmelCase						(	self	:					List[Any]						)->	int:
          snake_case__					:	str          =					NatModelTester(self						)
          snake_case__					:	Any          =					ConfigTester(self					, config_class=lowerCamelCase					, embed_dim=37						)




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




   def   __lowerCAmelCase						(	self	:					Optional[int]						)->	Optional[Any]:
          snake_case__					:	Optional[Any]          =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowerCamelCase						)




   def   __lowerCAmelCase						(	self	:					int						)->	Optional[int]:
          snake_case__					:	List[str]          =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowerCamelCase						)




   def   __lowerCAmelCase						(	self	:					Any						)->	Dict:
          snake_case__					:	Any          =					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   __lowerCAmelCase						(	self	:					Optional[int]						)->	Any:
          pass




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




   def   __lowerCAmelCase						(	self	:					str						)->	Tuple:
          snake_case__       ,   snake_case__					:	str          =					self.model_tester.prepare_config_and_inputs_for_common()

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




   def   __lowerCAmelCase						(	self	:					List[Any]						)->	Optional[Any]:
          snake_case__       ,   snake_case__					:	Dict          =					self.model_tester.prepare_config_and_inputs_for_common()

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

                 snake_case__					:	Optional[Any]          =					["""pixel_values"""]
                 self.assertListEqual(arg_names[:1]					, lowerCamelCase						)




   def   __lowerCAmelCase						(	self	:					str						)->	Any:
          self.skipTest("""Nat's attention operation is handled entirely by NATTEN."""						)




   def   __lowerCAmelCase						(	self	:					Optional[Any]					, lowerCamelCase	:					Any					, lowerCamelCase	:					Any					, lowerCamelCase	:					Dict					, lowerCamelCase	:					List[Any]						)->	int:
          snake_case__					:	str          =					model_class(lowerCamelCase						)
          model.to(lowerCamelCase						)
          model.eval()

          with torch.no_grad():
                 snake_case__					:	Tuple          =					model(**self._prepare_for_class(lowerCamelCase					, lowerCamelCase						)						)

          snake_case__					:	Union[str, Any]          =					outputs.hidden_states

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

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

                 snake_case__       ,   snake_case__       ,   snake_case__       ,   snake_case__					:	Union[str, Any]          =					reshaped_hidden_states[0].shape
                 snake_case__					:	List[Any]          =					(
                     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   __lowerCAmelCase						(	self	:					Optional[int]						)->	str:
          snake_case__       ,   snake_case__					:	Dict          =					self.model_tester.prepare_config_and_inputs_for_common()

          snake_case__					:	Dict          =					(
              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__					:	Union[str, Any]          =					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"]
                 snake_case__					:	Optional[Any]          =					True

                 self.check_hidden_states_output(lowerCamelCase					, lowerCamelCase					, lowerCamelCase					, lowerCamelCase						)




   @slow
   def   __lowerCAmelCase						(	self	:					Dict						)->	Optional[Any]:
          for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 snake_case__					:	Union[str, Any]          =					NatModel.from_pretrained(lowerCamelCase						)
                 self.assertIsNotNone(lowerCamelCase						)




   def   __lowerCAmelCase						(	self	:					List[Any]						)->	Optional[int]:
          snake_case__       ,   snake_case__					:	Union[str, Any]          =					self.model_tester.prepare_config_and_inputs_for_common()

          snake_case__					:	int          =					_config_zero_init(lowerCamelCase						)
          for model_class in self.all_model_classes:
                 snake_case__					:	List[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 					_A						(						unittest.TestCase							):



   '''simple docstring'''






   @cached_property
   def   __lowerCAmelCase						(	self	:					List[Any]						)->	int:
          return AutoImageProcessor.from_pretrained("""shi-labs/nat-mini-in1k-224"""						) if is_vision_available() else None




   @slow
   def   __lowerCAmelCase						(	self	:					Any						)->	Optional[Any]:
          snake_case__					:	Union[str, Any]          =					NatForImageClassification.from_pretrained("""shi-labs/nat-mini-in1k-224"""						).to(lowerCamelCase						)
          snake_case__					:	List[str]          =					self.default_image_processor

          snake_case__					:	List[str]          =					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
          snake_case__					:	Dict          =					image_processor(images=lowerCamelCase					, return_tensors="""pt"""						).to(lowerCamelCase						)

          # forward pass
          with torch.no_grad():
                 snake_case__					:	str          =					model(**lowerCamelCase						)

          # verify the logits
          snake_case__					:	Optional[int]          =					torch.Size((1, 1_000)						)
          self.assertEqual(outputs.logits.shape					, lowerCamelCase						)
          snake_case__					:	Any          =					torch.tensor([0.3_805, -0.8_676, -0.3_912]						).to(lowerCamelCase						)
          self.assertTrue(torch.allclose(outputs.logits[0, :3]					, lowerCamelCase					, atol=1e-4						)						)







@require_torch
@require_natten
class 					_A						(						unittest.TestCase    ,  UpperCamelCase							):



   '''simple docstring'''






   _lowercase    						= (NatBackbone,) if is_torch_available() else ()
   _lowercase    						= NatConfig




   def   __lowerCAmelCase						(	self	:					Tuple						)->	Optional[int]:
          snake_case__					:	Dict          =					NatModelTester(self						)








'''simple docstring'''
import unittest
from timeit import timeit



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       snake_case__					:	Any          =					first_num if first_num >= second_num else second_num
       snake_case__					:	Optional[Any]          =					max_num
       while (common_mult % first_num > 0) or (common_mult % second_num > 0):
              common_mult += max_num
       return common_mult



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       return b if a == 0 else greatest_common_divisor(b % a    ,       UpperCAmelCase     )



def 				lowerCAmelCase__	(       UpperCAmelCase    ,       UpperCAmelCase     ):






       """simple docstring"""





       return first_num // greatest_common_divisor(UpperCAmelCase    ,       UpperCAmelCase     ) * second_num



def 				lowerCAmelCase__	(       ):






       """simple docstring"""





       snake_case__					:	Tuple          =					(
           """from __main__ import least_common_multiple_slow, least_common_multiple_fast"""
       )
       print(
           """least_common_multiple_slow():"""    ,       timeit("""least_common_multiple_slow(1000, 999)"""    ,       setup=UpperCAmelCase     )    ,       )
       print(
           """least_common_multiple_fast():"""    ,       timeit("""least_common_multiple_fast(1000, 999)"""    ,       setup=UpperCAmelCase     )    ,       )







class 					_A						(						unittest.TestCase							):



   '''simple docstring'''






   _lowercase    						= (
       (10, 20),
       (13, 15),
       (4, 31),
       (10, 42),
       (43, 34),
       (5, 12),
       (12, 25),
       (10, 25),
       (6, 9),
   )
   _lowercase    						= (20, 195, 124, 210, 1462, 60, 300, 50, 18)




   def   __lowerCAmelCase						(	self	:					Optional[int]						)->	Optional[Any]:
          for i, (first_num, second_num) in enumerate(self.test_inputs						):
                 snake_case__					:	List[Any]          =					least_common_multiple_slow(lowerCamelCase					, lowerCamelCase						)
                 snake_case__					:	Optional[Any]          =					least_common_multiple_fast(lowerCamelCase					, lowerCamelCase						)
                 with self.subTest(i=lowerCamelCase						):
                        self.assertEqual(lowerCamelCase					, self.expected_results[i]						)
                        self.assertEqual(lowerCamelCase					, self.expected_results[i]						)


if __name__ == "__main__":
     benchmark()
     unittest.main()




