import collections
import inspect
import unittest

from transformers import DinatConfig
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 DinatBackbone, DinatForImageClassification, DinatModel
		from transformers.models.dinat.modeling_dinat import DINAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor






class 		a__						:

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







							"""simple docstring"""






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

					def     __UpperCamelCase       (   self				:	List[str]   ):







							"""simple docstring"""






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

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

							SCREAMING_SNAKE_CASE_  :		Union[str, Any]    				=   self.get_config()

							return config, pixel_values, labels

					def     __UpperCamelCase       (   self				:	Any   ):







							"""simple docstring"""






							return DinatConfig(
							    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,dilations=self.dilations,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     __UpperCamelCase       (   self				:	int,_A				:	str,_A				:	List[str],_A				:	Optional[Any]   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str    				=   DinatModel(config=_A   )
							model.to(_A   )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Optional[int]    				=   model(_A   )

							SCREAMING_SNAKE_CASE_  :		Dict    				=   (config.image_size // config.patch_size) // (2 ** (len(config.depths   ) - 1))
							SCREAMING_SNAKE_CASE_  :		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     __UpperCamelCase       (   self				:	Optional[Any],_A				:	Optional[int],_A				:	Dict,_A				:	Optional[Any]   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Any    				=   DinatForImageClassification(_A   )
							model.to(_A   )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Tuple    				=   model(_A,labels=_A   )
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_labels)   )

							# test greyscale images
							SCREAMING_SNAKE_CASE_  :		Optional[Any]    				=   1
							SCREAMING_SNAKE_CASE_  :		int    				=   DinatForImageClassification(_A   )
							model.to(_A   )
							model.eval()

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

					def     __UpperCamelCase       (   self				:	Dict,_A				:	str,_A				:	int,_A				:	int   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]    				=   DinatBackbone(config=_A   )
							model.to(_A   )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Any    				=   model(_A   )

							# 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
							SCREAMING_SNAKE_CASE_  :		int    				=   None
							SCREAMING_SNAKE_CASE_  :		str    				=   DinatBackbone(config=_A   )
							model.to(_A   )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		int    				=   model(_A   )

							# 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     __UpperCamelCase       (   self				:	Optional[int]   ):







							"""simple docstring"""






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







@require_natten
@require_torch
class 		a__						( A__   ,		A__   ,		unittest.TestCase ):
					A     	=							(
					    (
					        DinatModel,
					        DinatForImageClassification,
					        DinatBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					A     	=							(
					    {'feature-extraction': DinatModel, 'image-classification': DinatForImageClassification}
					    if is_torch_available()
					    else {}
					)
					A     	=							False

					A     	=							False
					A     	=							False
					A     	=							False
					A     	=							False

					def     __UpperCamelCase       (   self				:	str   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]    				=   DinatModelTester(self   )
							SCREAMING_SNAKE_CASE_  :		Optional[Any]    				=   ConfigTester(self,config_class=_A,embed_dim=37   )

					def     __UpperCamelCase       (   self				:	List[Any]   ):







							"""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     __UpperCamelCase       (   self				:	Optional[Any]   ):







							"""simple docstring"""






							return

					def     __UpperCamelCase       (   self				:	List[Any]   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Any    				=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_A   )

					def     __UpperCamelCase       (   self				:	List[str]   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int    				=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*_A   )

					def     __UpperCamelCase       (   self				:	List[Any]   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]    				=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*_A   )

					@unittest.skip(reason="Dinat does not use inputs_embeds"   )
					def     __UpperCamelCase       (   self				:	Union[str, Any]   ):







							"""simple docstring"""






							pass

					@unittest.skip(reason="Dinat does not use feedforward chunking"   )
					def     __UpperCamelCase       (   self				:	Dict   ):







							"""simple docstring"""






							pass

					def     __UpperCamelCase       (   self				:	List[str]   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple    				=   self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE_  :		Optional[int]    				=   model_class(_A   )
									self.assertIsInstance(model.get_input_embeddings(),(nn.Module)   )
									SCREAMING_SNAKE_CASE_  :		int    				=   model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(_A,nn.Linear   )   )

					def     __UpperCamelCase       (   self				:	Optional[int]   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]    				=   self.model_tester.prepare_config_and_inputs_for_common()

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

									SCREAMING_SNAKE_CASE_  :		List[str]    				=   ["pixel_values"]
									self.assertListEqual(arg_names[:1],_A   )

					def     __UpperCamelCase       (   self				:	int   ):







							"""simple docstring"""






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

					def     __UpperCamelCase       (   self				:	Any,_A				:	int,_A				:	Any,_A				:	str,_A				:	str   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Dict    				=   model_class(_A   )
							model.to(_A   )
							model.eval()

							with torch.no_grad():
									SCREAMING_SNAKE_CASE_  :		Any    				=   model(**self._prepare_for_class(_A,_A   )   )

							SCREAMING_SNAKE_CASE_  :		Any    				=   outputs.hidden_states

							SCREAMING_SNAKE_CASE_  :		Dict    				=   getattr(
							    self.model_tester,"expected_num_hidden_layers",len(self.model_tester.depths   ) + 1   )
							self.assertEqual(len(_A   ),_A   )

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

							SCREAMING_SNAKE_CASE_  :		Union[str, Any]    				=   image_size[0] // patch_size[0]
							SCREAMING_SNAKE_CASE_  :		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__ != "DinatBackbone":
									SCREAMING_SNAKE_CASE_  :		int    				=   outputs.reshaped_hidden_states
									self.assertEqual(len(_A   ),_A   )

									SCREAMING_SNAKE_CASE_  :		List[Any]    				=   reshaped_hidden_states[0].shape
									SCREAMING_SNAKE_CASE_  :		int    				=   (
									    reshaped_hidden_states[0].view(_A,_A,_A,_A   ).permute(0,2,3,1   )
									)
									self.assertListEqual(
									    list(reshaped_hidden_states.shape[-3:]   ),[height, width, self.model_tester.embed_dim],)

					def     __UpperCamelCase       (   self				:	str   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Union[str, Any]    				=   self.model_tester.prepare_config_and_inputs_for_common()

							SCREAMING_SNAKE_CASE_  :		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:
									SCREAMING_SNAKE_CASE_  :		Optional[int]    				=   True
									self.check_hidden_states_output(_A,_A,_A,_A   )

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

									self.check_hidden_states_output(_A,_A,_A,_A   )

					@slow
					def     __UpperCamelCase       (   self				:	List[Any]   ):







							"""simple docstring"""






							for model_name in DINAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE_  :		int    				=   DinatModel.from_pretrained(_A   )
									self.assertIsNotNone(_A   )






					def     __UpperCamelCase       (   self				:	str   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]    				=   self.model_tester.prepare_config_and_inputs_for_common()

							SCREAMING_SNAKE_CASE_  :		Any    				=   _config_zero_init(_A   )
							for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE_  :		Optional[int]    				=   model_class(config=_A   )
									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     __UpperCamelCase       (   self				:	Any   ):







							"""simple docstring"""






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






					@slow
					def     __UpperCamelCase       (   self				:	int   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Dict    				=   DinatForImageClassification.from_pretrained("shi-labs/dinat-mini-in1k-224"   ).to(_A   )
							SCREAMING_SNAKE_CASE_  :		Any    				=   self.default_image_processor

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

							# forward pass
							with torch.no_grad():
									SCREAMING_SNAKE_CASE_  :		Any    				=   model(**_A   )

							# verify the logits
							SCREAMING_SNAKE_CASE_  :		Optional[Any]    				=   torch.Size((1, 1000)   )
							self.assertEqual(outputs.logits.shape,_A   )
							SCREAMING_SNAKE_CASE_  :		str    				=   torch.tensor([-0.1545, -0.7667, 0.4642]   ).to(_A   )
							self.assertTrue(torch.allclose(outputs.logits[0, :3],_A,atol=1E-4   )   )







@require_torch
@require_natten
class 		a__						( unittest.TestCase   ,		A__ ):
					A     	=							(DinatBackbone,) if is_torch_available() else ()
					A     	=							DinatConfig

					def     __UpperCamelCase       (   self				:	Dict   ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple    				=   DinatModelTester(self   )

from __future__ import annotations

import sys




def 				_snake_case     (       lowerCAmelCase							:       int     ):
		"""simple docstring"""







		if n < 0:
				raise ValueError("Negative arguments are not supported"     )
		return _fib(lowerCAmelCase     )[0]




def 				_snake_case     (       lowerCAmelCase							:       int     ):
		"""simple docstring"""







		if n == 0:  # (F(0), F(1))
				return (0, 1)

		# F(2n) = F(n)[2F(n+1) − F(n)]
		# F(2n+1) = F(n+1)^2+F(n)^2
		SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_  :		Dict    				=   _fib(n // 2     )
		SCREAMING_SNAKE_CASE_  :		Optional[Any]    				=   a * (b * 2 - a)
		SCREAMING_SNAKE_CASE_  :		List[str]    				=   a * a + b * b
		return (d, c + d) if n % 2 else (c, d)


if __name__ == "__main__":
		__lowerCamelCase :     str          =  int(sys.argv[1])
		print(f'''fibonacci({n}) is {fibonacci(n)}''')
