

def a_		(       UpperCamelCase_   :							int  )							->   int:







 """simple docstring"""

 if not isinstance(UpperCamelCase_   ,					UpperCamelCase_  ):
  raise TypeError('recursive_lucas_number accepts only integer arguments.'  )
 if n_th_number == 0:
  return 2
 if n_th_number == 1:
  return 1

 return recursive_lucas_number(n_th_number - 1  ) + recursive_lucas_number(
     n_th_number - 2  )







def a_		(       UpperCamelCase_   :							int  )							->   int:







 """simple docstring"""

 if not isinstance(UpperCamelCase_   ,					UpperCamelCase_  ):
  raise TypeError('dynamic_lucas_number accepts only integer arguments.'  )
 lowerCamelCase						,	lowerCamelCase      						=    2, 1
 for _ in range(UpperCamelCase_  ):
  lowerCamelCase						,	lowerCamelCase      						=    b, a + b
 return a


if __name__ == "__main__":
 from doctest import testmod

 testmod()
 _lowerCAmelCase :	Any     				=    int(input('Enter the number of terms in lucas series:\n').strip())
 print('Using recursive function to calculate lucas series:')
 print(' '.join(str(recursive_lucas_number(i)) for i in range(n)))
 print('\nUsing dynamic function to calculate lucas series:')
 print(' '.join(str(dynamic_lucas_number(i)) for i in range(n)))







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


       '''simple docstring'''







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







        '''simple docstring'''

        lowerCamelCase      						=    parent
        lowerCamelCase      						=    batch_size
        lowerCamelCase      						=    image_size
        lowerCamelCase      						=    patch_size
        lowerCamelCase      						=    num_channels
        lowerCamelCase      						=    embed_dim
        lowerCamelCase      						=    depths
        lowerCamelCase      						=    num_heads
        lowerCamelCase      						=    kernel_size
        lowerCamelCase      						=    mlp_ratio
        lowerCamelCase      						=    qkv_bias
        lowerCamelCase      						=    hidden_dropout_prob
        lowerCamelCase      						=    attention_probs_dropout_prob
        lowerCamelCase      						=    drop_path_rate
        lowerCamelCase      						=    hidden_act
        lowerCamelCase      						=    patch_norm
        lowerCamelCase      						=    layer_norm_eps
        lowerCamelCase      						=    initializer_range
        lowerCamelCase      						=    is_training
        lowerCamelCase      						=    scope
        lowerCamelCase      						=    use_labels
        lowerCamelCase      						=    num_labels
        lowerCamelCase      						=    out_features
        lowerCamelCase      						=    out_indices

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







        '''simple docstring'''

        lowerCamelCase      						=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

        lowerCamelCase      						=    self.get_config()

        return config, pixel_values, labels

       def   lowerCamelCase__						(	self					:  Tuple     )   -> int:







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







        '''simple docstring'''

        lowerCamelCase      						=    NatModel(config=__snake_case     )
        model.to(__snake_case     )
        model.eval()
        lowerCamelCase      						=    model(__snake_case     )

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







        '''simple docstring'''

        lowerCamelCase      						=    NatForImageClassification(__snake_case     )
        model.to(__snake_case     )
        model.eval()
        lowerCamelCase      						=    model(__snake_case						,	labels=__snake_case     )
        self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.num_labels)     )

        # test greyscale images
        lowerCamelCase      						=    1
        lowerCamelCase      						=    NatForImageClassification(__snake_case     )
        model.to(__snake_case     )
        model.eval()

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

       def   lowerCamelCase__						(	self					:  Union[str, Any]						,	__snake_case					:  Any						,	__snake_case					:  Any						,	__snake_case					:  Dict     )   -> List[Any]:







        '''simple docstring'''

        lowerCamelCase      						=    NatBackbone(config=__snake_case     )
        model.to(__snake_case     )
        model.eval()
        lowerCamelCase      						=    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], 16, 16]     )

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

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







        '''simple docstring'''

        lowerCamelCase      						=    self.prepare_config_and_inputs()
        lowerCamelCase						,	lowerCamelCase						,	lowerCamelCase      						=    config_and_inputs
        lowerCamelCase      						=    {'pixel_values': pixel_values}
        return config, inputs_dict


@require_natten
@require_torch
class     lowerCAmelCase				(    __UpperCamelCase   ,				__UpperCamelCase   ,				unittest.TestCase				):


       '''simple docstring'''







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

       snake_case    							=	False
       snake_case    							=	False
       snake_case    							=	False
       snake_case    							=	False

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







        '''simple docstring'''

        lowerCamelCase      						=    NatModelTester(self     )
        lowerCamelCase      						=    ConfigTester(self						,	config_class=__snake_case						,	embed_dim=37     )

       def   lowerCamelCase__						(	self					:  Dict     )   -> str:







        '''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   lowerCamelCase__						(	self					:  Optional[Any]     )   -> Union[str, Any]:







        '''simple docstring'''

        return

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







        '''simple docstring'''

        lowerCamelCase      						=    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__snake_case     )

       def   lowerCamelCase__						(	self					:  Optional[int]     )   -> Optional[int]:







        '''simple docstring'''

        lowerCamelCase      						=    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__snake_case     )

       def   lowerCamelCase__						(	self					:  List[str]     )   -> Dict:







        '''simple docstring'''

        lowerCamelCase      						=    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   lowerCamelCase__						(	self					:  Tuple     )   -> Optional[int]:







        '''simple docstring'''

        pass

       @unittest.skip(reason='Nat does not use feedforward chunking'     )
       def   lowerCamelCase__						(	self					:  Optional[Any]     )   -> List[str]:







        '''simple docstring'''

        pass

       def   lowerCamelCase__						(	self					:  Tuple     )   -> str:







        '''simple docstring'''

        lowerCamelCase						,	lowerCamelCase      						=    self.model_tester.prepare_config_and_inputs_for_common()

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

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







        '''simple docstring'''

        lowerCamelCase						,	lowerCamelCase      						=    self.model_tester.prepare_config_and_inputs_for_common()

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

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

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







        '''simple docstring'''

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

       def   lowerCamelCase__						(	self					:  str						,	__snake_case					:  List[str]						,	__snake_case					:  Optional[Any]						,	__snake_case					:  Tuple						,	__snake_case					:  Union[str, Any]     )   -> int:







        '''simple docstring'''

        lowerCamelCase      						=    model_class(__snake_case     )
        model.to(__snake_case     )
        model.eval()

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

        lowerCamelCase      						=    outputs.hidden_states

        lowerCamelCase      						=    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
        lowerCamelCase      						=    (
            config.patch_size
            if isinstance(config.patch_size						,	collections.abc.Iterable     )
            else (config.patch_size, config.patch_size)
        )

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

         lowerCamelCase						,	lowerCamelCase						,	lowerCamelCase						,	lowerCamelCase      						=    reshaped_hidden_states[0].shape
         lowerCamelCase      						=    (
             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   lowerCamelCase__						(	self					:  Dict     )   -> Tuple:







        '''simple docstring'''

        lowerCamelCase						,	lowerCamelCase      						=    self.model_tester.prepare_config_and_inputs_for_common()

        lowerCamelCase      						=    (
            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      						=    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"]
         lowerCamelCase      						=    True

         self.check_hidden_states_output(__snake_case						,	__snake_case						,	__snake_case						,	__snake_case     )

       @slow
       def   lowerCamelCase__						(	self					:  Any     )   -> Optional[int]:







        '''simple docstring'''

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





       def   lowerCamelCase__						(	self					:  Any     )   -> Any:







        '''simple docstring'''

        lowerCamelCase						,	lowerCamelCase      						=    self.model_tester.prepare_config_and_inputs_for_common()

        lowerCamelCase      						=    _config_zero_init(__snake_case     )
        for model_class in self.all_model_classes:
         lowerCamelCase      						=    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     lowerCAmelCase				(    unittest.TestCase				):


       '''simple docstring'''







       @cached_property
       def   lowerCamelCase__						(	self					:  Union[str, Any]     )   -> Dict:







        '''simple docstring'''

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





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







        '''simple docstring'''

        lowerCamelCase      						=    NatForImageClassification.from_pretrained('shi-labs/nat-mini-in1k-224'     ).to(__snake_case     )
        lowerCamelCase      						=    self.default_image_processor

        lowerCamelCase      						=    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
        lowerCamelCase      						=    image_processor(images=__snake_case						,	return_tensors='pt'     ).to(__snake_case     )

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

        # verify the logits
        lowerCamelCase      						=    torch.Size((1, 1000)     )
        self.assertEqual(outputs.logits.shape						,	__snake_case     )
        lowerCamelCase      						=    torch.tensor([0.3805, -0.8676, -0.3912]     ).to(__snake_case     )
        self.assertTrue(torch.allclose(outputs.logits[0, :3]						,	__snake_case						,	atol=1e-4     )     )


@require_torch
@require_natten
class     lowerCAmelCase				(    unittest.TestCase   ,				__UpperCamelCase				):


       '''simple docstring'''







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

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







        '''simple docstring'''

        lowerCamelCase      						=    NatModelTester(self     )




