





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






				def __init__( self		:    int, lowerCAmelCase__		:    Any, lowerCAmelCase__		:    int=1_3, lowerCAmelCase__		:    str=6_4, lowerCAmelCase__		:    Union[str, Any]=4, lowerCAmelCase__		:    str=3, lowerCAmelCase__		:    List[Any]=1_6, lowerCAmelCase__		:    List[str]=[1, 2, 1], lowerCAmelCase__		:    int=[2, 4, 8], lowerCAmelCase__		:    Union[str, Any]=3, lowerCAmelCase__		:    Optional[int]=2.0, lowerCAmelCase__		:    Tuple=True, lowerCAmelCase__		:    Optional[Any]=0.0, lowerCAmelCase__		:    int=0.0, lowerCAmelCase__		:    Any=0.1, lowerCAmelCase__		:    Dict="gelu", lowerCAmelCase__		:    Any=True, lowerCAmelCase__		:    Dict=0.02, lowerCAmelCase__		:    Dict=1e-5, lowerCAmelCase__		:    Optional[Any]=True, lowerCAmelCase__		:    Dict=None, lowerCAmelCase__		:    str=True, lowerCAmelCase__		:    Any=1_0, lowerCAmelCase__		:    Dict=["stage1", "stage2"], lowerCAmelCase__		:    Dict=[1, 2], )	->      str:




										'''simple docstring'''



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






				def 				snake_case	( self		:    List[Any]							)	->      str:




										'''simple docstring'''



										_UpperCamelCase			:					Dict     =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

										_UpperCamelCase			:					int     =    self.get_config()

										return config, pixel_values, labels






				def 				snake_case	( self		:    Optional[Any]							)	->      Tuple:




										'''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 				snake_case	( self		:    List[Any], lowerCAmelCase__		:    Optional[Any], lowerCAmelCase__		:    int, lowerCAmelCase__		:    List[Any]							)	->      Optional[Any]:




										'''simple docstring'''



										_UpperCamelCase			:					Union[str, Any]     =    NatModel(config=lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()
										_UpperCamelCase			:					Any     =    model(lowerCAmelCase__							)

										_UpperCamelCase			:					Tuple     =    (config.image_size // config.patch_size) // (2 ** (len(config.depths							) - 1))
										_UpperCamelCase			:					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 				snake_case	( self		:    str, lowerCAmelCase__		:    List[str], lowerCAmelCase__		:    Optional[int], lowerCAmelCase__		:    Any							)	->      Optional[Any]:




										'''simple docstring'''



										_UpperCamelCase			:					Tuple     =    NatForImageClassification(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()
										_UpperCamelCase			:					Optional[int]     =    model(lowerCAmelCase__, labels=lowerCAmelCase__							)
										self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)							)

										# test greyscale images
										_UpperCamelCase			:					Tuple     =    1
										_UpperCamelCase			:					Tuple     =    NatForImageClassification(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()

										_UpperCamelCase			:					int     =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
										_UpperCamelCase			:					Optional[int]     =    model(lowerCAmelCase__							)
										self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels)							)






				def 				snake_case	( self		:    Dict, lowerCAmelCase__		:    List[str], lowerCAmelCase__		:    Union[str, Any], lowerCAmelCase__		:    Tuple							)	->      Tuple:




										'''simple docstring'''



										_UpperCamelCase			:					Any     =    NatBackbone(config=lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()
										_UpperCamelCase			:					Optional[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], 1_6, 1_6]							)

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

										# verify backbone works with out_features=None
										_UpperCamelCase			:					Optional[int]     =    None
										_UpperCamelCase			:					Optional[int]     =    NatBackbone(config=lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()
										_UpperCamelCase			:					str     =    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 				snake_case	( self		:    Optional[int]							)	->      Optional[int]:




										'''simple docstring'''



										_UpperCamelCase			:					Optional[int]     =    self.prepare_config_and_inputs()
										_UpperCamelCase   ,							_UpperCamelCase   ,							_UpperCamelCase			:					Tuple     =    config_and_inputs
										_UpperCamelCase			:					int     =    {'''pixel_values''': pixel_values}
										return config, inputs_dict




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

				UpperCamelCase								=    False
				UpperCamelCase								=    False
				UpperCamelCase								=    False
				UpperCamelCase								=    False






				def 				snake_case	( self		:    Union[str, Any]							)	->      Union[str, Any]:




										'''simple docstring'''



										_UpperCamelCase			:					List[Any]     =    NatModelTester(self							)
										_UpperCamelCase			:					List[str]     =    ConfigTester(self, config_class=lowerCAmelCase__, embed_dim=3_7							)






				def 				snake_case	( self		:    Dict							)	->      Tuple:




										'''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 				snake_case	( self		:    Any							)	->      List[Any]:




										'''simple docstring'''



										return






				def 				snake_case	( self		:    int							)	->      Any:




										'''simple docstring'''



										_UpperCamelCase			:					Optional[Any]     =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase__							)






				def 				snake_case	( self		:    Union[str, Any]							)	->      str:




										'''simple docstring'''



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






				def 				snake_case	( self		:    Any							)	->      List[str]:




										'''simple docstring'''



										_UpperCamelCase			:					List[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 				snake_case	( self		:    Dict							)	->      Dict:




										'''simple docstring'''



										pass






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




										'''simple docstring'''



										pass






				def 				snake_case	( self		:    Union[str, Any]							)	->      Tuple:




										'''simple docstring'''



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

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






				def 				snake_case	( self		:    str							)	->      Union[str, Any]:




										'''simple docstring'''



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

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

																_UpperCamelCase			:					Optional[int]     =    ['''pixel_values''']
																self.assertListEqual(arg_names[:1], lowerCAmelCase__							)






				def 				snake_case	( self		:    List[Any]							)	->      Optional[Any]:




										'''simple docstring'''



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






				def 				snake_case	( self		:    Optional[Any], lowerCAmelCase__		:    List[Any], lowerCAmelCase__		:    List[str], lowerCAmelCase__		:    List[str], lowerCAmelCase__		:    int							)	->      Tuple:




										'''simple docstring'''



										_UpperCamelCase			:					Dict     =    model_class(lowerCAmelCase__							)
										model.to(lowerCAmelCase__							)
										model.eval()

										with torch.no_grad():
																_UpperCamelCase			:					Dict     =    model(**self._prepare_for_class(lowerCAmelCase__, lowerCAmelCase__							)							)

										_UpperCamelCase			:					str     =    outputs.hidden_states

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

										_UpperCamelCase			:					List[Any]     =    image_size[0] // patch_size[0]
										_UpperCamelCase			:					List[str]     =    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":
																_UpperCamelCase			:					Union[str, Any]     =    outputs.reshaped_hidden_states
																self.assertEqual(len(lowerCAmelCase__							), lowerCAmelCase__							)

																_UpperCamelCase   ,							_UpperCamelCase   ,							_UpperCamelCase   ,							_UpperCamelCase			:					Optional[Any]     =    reshaped_hidden_states[0].shape
																_UpperCamelCase			:					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 				snake_case	( self		:    Dict							)	->      int:




										'''simple docstring'''



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

										_UpperCamelCase			:					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:
																_UpperCamelCase			:					Dict     =    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"]
																_UpperCamelCase			:					Union[str, Any]     =    True

																self.check_hidden_states_output(lowerCAmelCase__, lowerCAmelCase__, lowerCAmelCase__, lowerCAmelCase__							)






				@slow
				def 				snake_case	( self		:    int							)	->      Dict:




										'''simple docstring'''



										for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCamelCase			:					Any     =    NatModel.from_pretrained(lowerCAmelCase__							)
																self.assertIsNotNone(lowerCAmelCase__							)






				def 				snake_case	( self		:    Optional[int]							)	->      Union[str, Any]:




										'''simple docstring'''



										_UpperCamelCase   ,							_UpperCamelCase			:					str     =    self.model_tester.prepare_config_and_inputs_for_common()

										_UpperCamelCase			:					Optional[Any]     =    _config_zero_init(lowerCAmelCase__							)
										for model_class in self.all_model_classes:
																_UpperCamelCase			:					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				):






				@cached_property
				def 				snake_case	( self		:    List[str]							)	->      Tuple:




										'''simple docstring'''



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






				@slow
				def 				snake_case	( self		:    List[str]							)	->      str:




										'''simple docstring'''



										_UpperCamelCase			:					str     =    NatForImageClassification.from_pretrained('''shi-labs/nat-mini-in1k-224'''							).to(lowerCAmelCase__							)
										_UpperCamelCase			:					List[str]     =    self.default_image_processor

										_UpperCamelCase			:					Dict     =    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
										_UpperCamelCase			:					str     =    image_processor(images=lowerCAmelCase__, return_tensors='''pt'''							).to(lowerCAmelCase__							)

										# forward pass
										with torch.no_grad():
																_UpperCamelCase			:					Optional[int]     =    model(**lowerCAmelCase__							)

										# verify the logits
										_UpperCamelCase			:					int     =    torch.Size((1, 1_0_0_0)							)
										self.assertEqual(outputs.logits.shape, lowerCAmelCase__							)
										_UpperCamelCase			:					List[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	,				_lowerCAmelCase				):
				UpperCamelCase								=    (NatBackbone,) if is_torch_available() else ()
				UpperCamelCase								=    NatConfig






				def 				snake_case	( self		:    Union[str, Any]							)	->      str:




										'''simple docstring'''



										_UpperCamelCase			:					List[Any]     =    NatModelTester(self							)










"""simple docstring"""




from functools import lru_cache





@lru_cache
def        a_				(							_lowercase   ):
						if not isinstance(_lowercase       ,						_lowercase   ):
												raise TypeError('''k must be an integer.'''   )
						if k < 0:
												raise ValueError('''k integer must be greater or equal to zero.'''   )
						if k == 0:
												return 0
						elif k == 1:
												return 1
						else:
												return fibonacci(k - 1   ) + fibonacci(k - 2   )





def        a_				(							_lowercase       ,						_lowercase   ):
						_UpperCamelCase			:					Any     =    len(_lowercase   )
						# Find m such that F_m >= n where F_i is the i_th fibonacci number.
						_UpperCamelCase			:					Optional[int]     =    0
						while True:
												if fibonacci(_lowercase   ) >= len_list:
																		_UpperCamelCase			:					List[Any]     =    i
																		break
												i += 1
						_UpperCamelCase			:					Tuple     =    0
						while fibb_k > 0:
												_UpperCamelCase			:					Union[str, Any]     =    min(
												    offset + fibonacci(fibb_k - 1   )       ,						len_list - 1   )  # Prevent out of range
												_UpperCamelCase			:					Any     =    arr[index_k]
												if item_k_1 == val:
																		return index_k
												elif val < item_k_1:
																		fibb_k -= 1
												elif val > item_k_1:
																		offset += fibonacci(fibb_k - 1   )
																		fibb_k -= 2
						else:
												return -1


if __name__ == "__main__":
						import doctest

						doctest.testmod()



