





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:







		def __init__(     self			,    __snake_case			,    __snake_case=1_3			,    __snake_case=6_4			,    __snake_case=4			,    __snake_case=3			,    __snake_case=1_6			,    __snake_case=[1, 2, 1]			,    __snake_case=[2, 4, 8]			,    __snake_case=3			,    __snake_case=2.0			,    __snake_case=True			,    __snake_case=0.0			,    __snake_case=0.0			,    __snake_case=0.1			,    __snake_case="gelu"			,    __snake_case=True			,    __snake_case=0.02			,    __snake_case=1E-5			,    __snake_case=True			,    __snake_case=None			,    __snake_case=True			,    __snake_case=1_0			,    __snake_case=["stage1", "stage2"]			,    __snake_case=[1, 2]			,    )   ->   str:


							'''simple docstring'''

							_snake_case							:       Any												= parent
							_snake_case							:       str												= batch_size
							_snake_case							:       List[Any]												= image_size
							_snake_case							:       str												= patch_size
							_snake_case							:       Dict												= num_channels
							_snake_case							:       Optional[int]												= embed_dim
							_snake_case							:       Optional[Any]												= depths
							_snake_case							:       Dict												= num_heads
							_snake_case							:       str												= kernel_size
							_snake_case							:       Optional[Any]												= mlp_ratio
							_snake_case							:       str												= qkv_bias
							_snake_case							:       Optional[int]												= hidden_dropout_prob
							_snake_case							:       Optional[Any]												= attention_probs_dropout_prob
							_snake_case							:       Tuple												= drop_path_rate
							_snake_case							:       Tuple												= hidden_act
							_snake_case							:       Union[str, Any]												= patch_norm
							_snake_case							:       str												= layer_norm_eps
							_snake_case							:       str												= initializer_range
							_snake_case							:       List[Any]												= is_training
							_snake_case							:       Tuple												= scope
							_snake_case							:       Optional[int]												= use_labels
							_snake_case							:       Union[str, Any]												= num_labels
							_snake_case							:       Optional[Any]												= out_features
							_snake_case							:       Any												= out_indices







		def 							lowercase							(     self					)   ->   int:


							'''simple docstring'''

							_snake_case							:       Optional[int]												= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

							_snake_case							:       List[str]												= self.get_config()

							return config, pixel_values, labels







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


							'''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			,    __snake_case			,    __snake_case			,    __snake_case					)   ->   Union[str, Any]:


							'''simple docstring'''

							_snake_case							:       Union[str, Any]												= NatModel(config=__snake_case					)
							model.to(__snake_case					)
							model.eval()
							_snake_case							:       List[str]												= model(__snake_case					)

							_snake_case							:       Tuple												= (config.image_size // config.patch_size) // (2 ** (len(config.depths					) - 1))
							_snake_case							:       Union[str, Any]												= 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			,    __snake_case			,    __snake_case			,    __snake_case					)   ->   Union[str, Any]:


							'''simple docstring'''

							_snake_case							:       Any												= NatForImageClassification(__snake_case					)
							model.to(__snake_case					)
							model.eval()
							_snake_case							:       Optional[int]												= model(__snake_case			,    labels=__snake_case					)
							self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.num_labels)					)

							# test greyscale images
							_snake_case							:       Optional[int]												= 1
							_snake_case							:       Any												= NatForImageClassification(__snake_case					)
							model.to(__snake_case					)
							model.eval()

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







		def 							lowercase							(     self			,    __snake_case			,    __snake_case			,    __snake_case					)   ->   Tuple:


							'''simple docstring'''

							_snake_case							:       Dict												= NatBackbone(config=__snake_case					)
							model.to(__snake_case					)
							model.eval()
							_snake_case							:       List[Any]												= model(__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], 1_6, 1_6]					)

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

							# verify backbone works with out_features=None
							_snake_case							:       List[Any]												= None
							_snake_case							:       Optional[Any]												= NatBackbone(config=__snake_case					)
							model.to(__snake_case					)
							model.eval()
							_snake_case							:       Union[str, Any]												= model(__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					)   ->   Union[str, Any]:


							'''simple docstring'''

							_snake_case							:       Union[str, Any]												= self.prepare_config_and_inputs()
							_snake_case							,			_snake_case							,			_snake_case							:       int												= config_and_inputs
							_snake_case							:       Union[str, Any]												= {"pixel_values": pixel_values}
							return config, inputs_dict






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

		lowerCamelCase__  :Optional[int] 					=		False
		lowerCamelCase__  :str 					=		False
		lowerCamelCase__  :List[str] 					=		False
		lowerCamelCase__  :Tuple 					=		False







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


							'''simple docstring'''

							_snake_case							:       List[str]												= NatModelTester(self					)
							_snake_case							:       Tuple												= ConfigTester(self			,    config_class=__snake_case			,    embed_dim=3_7					)







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


							'''simple docstring'''

							return







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


							'''simple docstring'''

							_snake_case							:       List[str]												= self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__snake_case					)







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


							'''simple docstring'''

							_snake_case							:       Union[str, Any]												= self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__snake_case					)







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


							'''simple docstring'''

							_snake_case							:       Union[str, Any]												= self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*__snake_case					)







		@unittest.skip(reason="Nat does not use inputs_embeds"					)
		def 							lowercase							(     self					)   ->   int:


							'''simple docstring'''

							pass







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


							'''simple docstring'''

							pass







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


							'''simple docstring'''

							_snake_case							,			_snake_case							:       Optional[int]												= self.model_tester.prepare_config_and_inputs_for_common()

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







		def 							lowercase							(     self					)   ->   Tuple:


							'''simple docstring'''

							_snake_case							,			_snake_case							:       int												= self.model_tester.prepare_config_and_inputs_for_common()

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

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







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


							'''simple docstring'''

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







		def 							lowercase							(     self			,    __snake_case			,    __snake_case			,    __snake_case			,    __snake_case					)   ->   Any:


							'''simple docstring'''

							_snake_case							:       Optional[Any]												= model_class(__snake_case					)
							model.to(__snake_case					)
							model.eval()

							with torch.no_grad():
												_snake_case							:       List[str]												= model(**self._prepare_for_class(__snake_case			,    __snake_case					)					)

							_snake_case							:       Dict												= outputs.hidden_states

							_snake_case							:       Optional[Any]												= getattr(
							    self.model_tester			,    "expected_num_hidden_layers"			,    len(self.model_tester.depths					) + 1					)
							self.assertEqual(len(__snake_case					)			,    __snake_case					)

							# Nat has a different seq_length
							_snake_case							:       int												= (
							    config.patch_size
							    if isinstance(config.patch_size			,    collections.abc.Iterable					)
							    else (config.patch_size, config.patch_size)
							)

							_snake_case							:       Optional[int]												= image_size[0] // patch_size[0]
							_snake_case							:       Tuple												= 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							:       int												= outputs.reshaped_hidden_states
												self.assertEqual(len(__snake_case					)			,    __snake_case					)

												_snake_case							,			_snake_case							,			_snake_case							,			_snake_case							:       Any												= reshaped_hidden_states[0].shape
												_snake_case							:       Optional[int]												= (
												    reshaped_hidden_states[0].view(__snake_case			,    __snake_case			,    __snake_case			,    __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					)   ->   str:


							'''simple docstring'''

							_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							:       Any												= True
												self.check_hidden_states_output(__snake_case			,    __snake_case			,    __snake_case			,    __snake_case					)

												# 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(__snake_case			,    __snake_case			,    __snake_case			,    __snake_case					)







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


							'''simple docstring'''

							for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_snake_case							:       Tuple												= NatModel.from_pretrained(__snake_case					)
												self.assertIsNotNone(__snake_case					)







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


							'''simple docstring'''

							_snake_case							,			_snake_case							:       Optional[Any]												= self.model_tester.prepare_config_and_inputs_for_common()

							_snake_case							:       Tuple												= _config_zero_init(__snake_case					)
							for model_class in self.all_model_classes:
												_snake_case							:       Optional[Any]												= model_class(config=__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 							_a(     unittest.TestCase     ):







		@cached_property
		def 							lowercase							(     self					)   ->   Any:


							'''simple docstring'''

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







		@slow
		def 							lowercase							(     self					)   ->   int:


							'''simple docstring'''

							_snake_case							:       Dict												= NatForImageClassification.from_pretrained("shi-labs/nat-mini-in1k-224"					).to(__snake_case					)
							_snake_case							:       Tuple												= self.default_image_processor

							_snake_case							:       List[Any]												= Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
							_snake_case							:       Union[str, Any]												= image_processor(images=__snake_case			,    return_tensors="pt"					).to(__snake_case					)

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

							# verify the logits
							_snake_case							:       int												= torch.Size((1, 1_0_0_0)					)
							self.assertEqual(outputs.logits.shape			,    __snake_case					)
							_snake_case							:       Dict												= torch.tensor([0.38_05, -0.86_76, -0.39_12]					).to(__snake_case					)
							self.assertTrue(torch.allclose(outputs.logits[0, :3]			,    __snake_case			,    atol=1E-4					)					)






@require_torch
@require_natten
class 							_a(     unittest.TestCase						, __A     ):
		lowerCamelCase__  :Any 					=		(NatBackbone,) if is_torch_available() else ()
		lowerCamelCase__  :List[Any] 					=		NatConfig







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


							'''simple docstring'''

							_snake_case							:       int												= NatModelTester(self					)






def  A					(				UpperCAmelCase	,	UpperCAmelCase					):
					# "Simpson Rule"
					# int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
					_snake_case							:       List[str]												= (boundary[1] - boundary[0]) / steps
					_snake_case							:       List[Any]												= boundary[0]
					_snake_case							:       Tuple												= boundary[1]
					_snake_case							:       str												= make_points(UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase					)
					_snake_case							:       str												= 0.0
					y += (h / 3.0) * f(UpperCAmelCase					)
					_snake_case							:       Tuple												= 2
					for i in x_i:
										y += (h / 3) * (4 - 2 * (cnt % 2)) * f(UpperCAmelCase					)
										cnt += 1
					y += (h / 3.0) * f(UpperCAmelCase					)
					return y







def  A					(				UpperCAmelCase	,	UpperCAmelCase	,	UpperCAmelCase					):
					_snake_case							:       Union[str, Any]												= a + h
					while x < (b - h):
										yield x
										_snake_case							:       Optional[Any]												= x + h







def  A					(				UpperCAmelCase					):  # enter your function here
					_snake_case							:       Dict												= (x - 0) * (x - 0)
					return y







def  A					(				):
					_snake_case							:       int												= 0.0  # Lower bound of integration
					_snake_case							:       Union[str, Any]												= 1.0  # Upper bound of integration
					_snake_case							:       List[str]												= 1_0.0  # define number of steps or resolution
					_snake_case							:       Optional[int]												= [a, b]  # define boundary of integration
					_snake_case							:       List[str]												= method_a(UpperCAmelCase	,	UpperCAmelCase					)
					print(F"""y = {y}"""					)


if __name__ == "__main__":
							main()