





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







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







		def       __lowercase (		self )					-> Dict:
				lowerCamelCase :			Dict    		=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

				lowerCamelCase :			str    		=self.get_config()

				return config, pixel_values, labels







		def       __lowercase (		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       __lowercase (		self      ,  __lowercase      ,  __lowercase      ,  __lowercase )					-> Dict:
				lowerCamelCase :			List[str]    		=NatModel(config=__lowercase )
				model.to(__lowercase )
				model.eval()
				lowerCamelCase :			Tuple    		=model(__lowercase )

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

				# test greyscale images
				lowerCamelCase :			int    		=1
				lowerCamelCase :			Tuple    		=NatForImageClassification(__lowercase )
				model.to(__lowercase )
				model.eval()

				lowerCamelCase :			Union[str, Any]    		=floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
				lowerCamelCase :			Any    		=model(__lowercase )
				self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_labels) )







		def       __lowercase (		self      ,  __lowercase      ,  __lowercase      ,  __lowercase )					-> Dict:
				lowerCamelCase :			List[str]    		=NatBackbone(config=__lowercase )
				model.to(__lowercase )
				model.eval()
				lowerCamelCase :			Optional[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], 1_6, 1_6] )

				# verify channels
				self.parent.assertEqual(len(model.channels )      ,  len(config.out_features ) )

				# verify backbone works with out_features=None
				lowerCamelCase :			Dict    		=None
				lowerCamelCase :			Dict    		=NatBackbone(config=__lowercase )
				model.to(__lowercase )
				model.eval()
				lowerCamelCase :			Optional[Any]    		=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       __lowercase (		self )					-> int:
				lowerCamelCase :			Any    		=self.prepare_config_and_inputs()
				lowerCamelCase		, lowerCamelCase		, lowerCamelCase :			str    		=config_and_inputs
				lowerCamelCase :			List[str]    		={'''pixel_values''': pixel_values}
				return config, inputs_dict

@require_natten
@require_torch
class 							snake_case_		(      _A    ,       _A    ,       unittest.TestCase):
		lowerCamelCase     :int							=  (
		    (
		        NatModel,
		        NatForImageClassification,
		        NatBackbone,
		    )
		    if is_torch_available()
		    else ()
		)
		lowerCamelCase     :Any							=  (
		    {"feature-extraction": NatModel, "image-classification": NatForImageClassification}
		    if is_torch_available()
		    else {}
		)
		lowerCamelCase     :Union[str, Any]							=  False

		lowerCamelCase     :List[Any]							=  False
		lowerCamelCase     :str							=  False
		lowerCamelCase     :Tuple							=  False
		lowerCamelCase     :Union[str, Any]							=  False







		def       __lowercase (		self )					-> Dict:
				lowerCamelCase :			Optional[int]    		=NatModelTester(self )
				lowerCamelCase :			Dict    		=ConfigTester(self      ,  config_class=__lowercase      ,  embed_dim=3_7 )







		def       __lowercase (		self )					-> Dict:
				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 )					-> List[Any]:
				return







		def       __lowercase (		self )					-> int:
				lowerCamelCase :			int    		=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*__lowercase )







		def       __lowercase (		self )					-> Optional[Any]:
				lowerCamelCase :			str    		=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*__lowercase )







		def       __lowercase (		self )					-> int:
				lowerCamelCase :			str    		=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_backbone(*__lowercase )







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







		@unittest.skip(reason='''Nat does not use feedforward chunking''' )
		def       __lowercase (		self )					-> Optional[int]:
				pass







		def       __lowercase (		self )					-> str:
				lowerCamelCase		, lowerCamelCase :			Dict    		=self.model_tester.prepare_config_and_inputs_for_common()

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







		def       __lowercase (		self )					-> Optional[int]:
				lowerCamelCase		, lowerCamelCase :			Dict    		=self.model_tester.prepare_config_and_inputs_for_common()

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

						lowerCamelCase :			Any    		=['''pixel_values''']
						self.assertListEqual(arg_names[:1]      ,  __lowercase )







		def       __lowercase (		self )					-> Dict:
				self.skipTest('''Nat\'s attention operation is handled entirely by NATTEN.''' )







		def       __lowercase (		self      ,  __lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase )					-> int:
				lowerCamelCase :			List[Any]    		=model_class(__lowercase )
				model.to(__lowercase )
				model.eval()

				with torch.no_grad():
						lowerCamelCase :			str    		=model(**self._prepare_for_class(__lowercase      ,  __lowercase ) )

				lowerCamelCase :			Dict    		=outputs.hidden_states

				lowerCamelCase :			Optional[Any]    		=getattr(
				    self.model_tester      ,  '''expected_num_hidden_layers'''      ,  len(self.model_tester.depths ) + 1 )
				self.assertEqual(len(__lowercase )      ,  __lowercase )

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

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

						lowerCamelCase		, lowerCamelCase		, lowerCamelCase		, lowerCamelCase :			Dict    		=reshaped_hidden_states[0].shape
						lowerCamelCase :			Dict    		=(
						    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       __lowercase (		self )					-> int:
				lowerCamelCase		, lowerCamelCase :			int    		=self.model_tester.prepare_config_and_inputs_for_common()

				lowerCamelCase :			Tuple    		=(
				    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:
						lowerCamelCase :			List[str]    		=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"]
						lowerCamelCase :			int    		=True

						self.check_hidden_states_output(__lowercase      ,  __lowercase      ,  __lowercase      ,  __lowercase )







		@slow
		def       __lowercase (		self )					-> Optional[Any]:
				for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowerCamelCase :			List[Any]    		=NatModel.from_pretrained(__lowercase )
						self.assertIsNotNone(__lowercase )







		def       __lowercase (		self )					-> Dict:
				lowerCamelCase		, lowerCamelCase :			Dict    		=self.model_tester.prepare_config_and_inputs_for_common()

				lowerCamelCase :			str    		=_config_zero_init(__lowercase )
				for model_class in self.all_model_classes:
						lowerCamelCase :			Any    		=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 							snake_case_		(      unittest.TestCase):







		@cached_property
		def       __lowercase (		self )					-> Optional[int]:
				return AutoImageProcessor.from_pretrained('''shi-labs/nat-mini-in1k-224''' ) if is_vision_available() else None







		@slow
		def       __lowercase (		self )					-> Dict:
				lowerCamelCase :			str    		=NatForImageClassification.from_pretrained('''shi-labs/nat-mini-in1k-224''' ).to(__lowercase )
				lowerCamelCase :			str    		=self.default_image_processor

				lowerCamelCase :			Optional[Any]    		=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
				lowerCamelCase :			Optional[Any]    		=image_processor(images=__lowercase      ,  return_tensors='''pt''' ).to(__lowercase )

				# forward pass
				with torch.no_grad():
						lowerCamelCase :			Union[str, Any]    		=model(**__lowercase )

				# verify the logits
				lowerCamelCase :			List[str]    		=torch.Size((1, 1_0_0_0) )
				self.assertEqual(outputs.logits.shape      ,  __lowercase )
				lowerCamelCase :			str    		=torch.tensor([0.3_8_0_5, -0.8_6_7_6, -0.3_9_1_2] ).to(__lowercase )
				self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,  __lowercase      ,  atol=1e-4 ) )

@require_torch
@require_natten
class 							snake_case_		(      unittest.TestCase    ,       _A):
		lowerCamelCase     :Union[str, Any]							=  (NatBackbone,) if is_torch_available() else ()
		lowerCamelCase     :List[Any]							=  NatConfig







		def       __lowercase (		self )					-> str:
				lowerCamelCase :			Any    		=NatModelTester(self )








def        A__						(							SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_		) ->  Union[str, Any]:
		if n < 0:
				return 0
		# table[i] represents the number of ways to get to amount i
		lowerCamelCase :			int    		=[0] * (n + 1)

		# There is exactly 1 way to get to zero(You pick no coins).
		lowerCamelCase :			List[Any]    		=1

		# Pick all coins one by one and update table[] values
		# after the index greater than or equal to the value of the
		# picked coin
		for coin_val in s:
				for j in range(SCREAMING_SNAKE_CASE_				,							n + 1		):
						table[j] += table[j - coin_val]

		return table[n]


if __name__ == "__main__":
				import doctest

				doctest.testmod()

