


'''simple docstring'''

import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import 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 SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
       from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import AutoImageProcessor







class 			UpperCAmelCase			:

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





    """simple docstring"""



    UpperCamelCase__			    =    parent
    UpperCamelCase__			    =    batch_size
    UpperCamelCase__			    =    image_size
    UpperCamelCase__			    =    patch_size
    UpperCamelCase__			    =    num_channels
    UpperCamelCase__			    =    embed_dim
    UpperCamelCase__			    =    depths
    UpperCamelCase__			    =    num_heads
    UpperCamelCase__			    =    window_size
    UpperCamelCase__			    =    mlp_ratio
    UpperCamelCase__			    =    qkv_bias
    UpperCamelCase__			    =    hidden_dropout_prob
    UpperCamelCase__			    =    attention_probs_dropout_prob
    UpperCamelCase__			    =    drop_path_rate
    UpperCamelCase__			    =    hidden_act
    UpperCamelCase__			    =    use_absolute_embeddings
    UpperCamelCase__			    =    patch_norm
    UpperCamelCase__			    =    layer_norm_eps
    UpperCamelCase__			    =    initializer_range
    UpperCamelCase__			    =    is_training
    UpperCamelCase__			    =    scope
    UpperCamelCase__			    =    use_labels
    UpperCamelCase__			    =    type_sequence_label_size
    UpperCamelCase__			    =    encoder_stride
    UpperCamelCase__			    =    out_features
    UpperCamelCase__			    =    out_indices

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



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

    UpperCamelCase__			    =    None
    if self.use_labels:
       UpperCamelCase__			    =    ids_tensor([self.batch_size],       self.type_sequence_label_size       )

    UpperCamelCase__			    =    self.get_config()

    return config, pixel_values, labels

 def 		lowercase_    (			self			:						Union[str, Any]       ):





    """simple docstring"""



    return SwinConfig(
        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,       window_size=self.window_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,       use_absolute_embeddings=self.use_absolute_embeddings,       path_norm=self.patch_norm,       layer_norm_eps=self.layer_norm_eps,       initializer_range=self.initializer_range,       encoder_stride=self.encoder_stride,       out_features=self.out_features,       out_indices=self.out_indices,       )

 def 		lowercase_    (			self			:						str,       a_			:						List[Any],       a_			:						List[str],       a_			:						Optional[int]       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinModel(config=__lowerCamelCase       )
    model.to(__lowerCamelCase       )
    model.eval()
    UpperCamelCase__			    =    model(__lowerCamelCase       )

    UpperCamelCase__			    =    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths       ) - 1))
    UpperCamelCase__			    =    int(config.embed_dim * 2 ** (len(config.depths       ) - 1)       )

    self.parent.assertEqual(result.last_hidden_state.shape,       (self.batch_size, expected_seq_len, expected_dim)       )

 def 		lowercase_    (			self			:						List[Any],       a_			:						List[Any],       a_			:						Union[str, Any],       a_			:						Optional[int]       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinBackbone(config=__lowerCamelCase       )
    model.to(__lowerCamelCase       )
    model.eval()
    UpperCamelCase__			    =    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], 16, 16]       )

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

    # verify backbone works with out_features=None
    UpperCamelCase__			    =    None
    UpperCamelCase__			    =    SwinBackbone(config=__lowerCamelCase       )
    model.to(__lowerCamelCase       )
    model.eval()
    UpperCamelCase__			    =    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 		lowercase_    (			self			:						List[Any],       a_			:						Union[str, Any],       a_			:						Union[str, Any],       a_			:						Any       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinForMaskedImageModeling(config=__lowerCamelCase       )
    model.to(__lowerCamelCase       )
    model.eval()
    UpperCamelCase__			    =    model(__lowerCamelCase       )
    self.parent.assertEqual(
        result.logits.shape,       (self.batch_size, self.num_channels, self.image_size, self.image_size)       )

    # test greyscale images
    UpperCamelCase__			    =    1
    UpperCamelCase__			    =    SwinForMaskedImageModeling(__lowerCamelCase       )
    model.to(__lowerCamelCase       )
    model.eval()

    UpperCamelCase__			    =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
    UpperCamelCase__			    =    model(__lowerCamelCase       )
    self.parent.assertEqual(result.logits.shape,       (self.batch_size, 1, self.image_size, self.image_size)       )

 def 		lowercase_    (			self			:						Dict,       a_			:						Optional[Any],       a_			:						Any,       a_			:						List[str]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.type_sequence_label_size
    UpperCamelCase__			    =    SwinForImageClassification(__lowerCamelCase       )
    model.to(__lowerCamelCase       )
    model.eval()
    UpperCamelCase__			    =    model(__lowerCamelCase,       labels=__lowerCamelCase       )
    self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.type_sequence_label_size)       )

    # test greyscale images
    UpperCamelCase__			    =    1
    UpperCamelCase__			    =    SwinForImageClassification(__lowerCamelCase       )
    model.to(__lowerCamelCase       )
    model.eval()

    UpperCamelCase__			    =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
    UpperCamelCase__			    =    model(__lowerCamelCase       )
    self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.type_sequence_label_size)       )

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.prepare_config_and_inputs()
    (
        UpperCamelCase__ 
    )			    =    config_and_inputs
    UpperCamelCase__			    =    {"""pixel_values""": pixel_values}
    return config, inputs_dict







@require_torch
class 			UpperCAmelCase			(							_a		,      _a		,      unittest.TestCase):
 _lowerCamelCase			:       int            =       (
     (
         SwinModel,
         SwinBackbone,
         SwinForImageClassification,
         SwinForMaskedImageModeling,
     )
     if is_torch_available()
     else ()
 )
 _lowerCamelCase			:       Any            =       (
     {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
     if is_torch_available()
     else {}
 )
 _lowerCamelCase			:       Optional[int]            =       True

 _lowerCamelCase			:       int            =       False
 _lowerCamelCase			:       Tuple            =       False
 _lowerCamelCase			:       List[str]            =       False

 def 		lowercase_    (			self			:						Optional[int]       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinModelTester(self       )
    UpperCamelCase__			    =    ConfigTester(self,       config_class=__lowerCamelCase,       embed_dim=37       )

 def 		lowercase_    (			self			:						Dict       ):





    """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			:						Optional[int]       ):





    """simple docstring"""



    return

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*__lowerCamelCase       )

 @unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0."       )
 def 		lowercase_    (			self			:						Any       ):





    """simple docstring"""



    pass

 def 		lowercase_    (			self			:						Optional[Any]       ):





    """simple docstring"""



    super().test_training_gradient_checkpointing()

 def 		lowercase_    (			self			:						str       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_backbone(*__lowerCamelCase       )

 def 		lowercase_    (			self			:						Optional[int]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_image_modeling(*__lowerCamelCase       )

 def 		lowercase_    (			self			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase       )

 @unittest.skip(reason="Swin does not use inputs_embeds"       )
 def 		lowercase_    (			self			:						Optional[Any]       ):





    """simple docstring"""



    pass

 @unittest.skip(reason="Swin Transformer does not use feedforward chunking"       )
 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    pass

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_common()

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

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_common()

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

       UpperCamelCase__			    =    ["""pixel_values"""]
       self.assertListEqual(arg_names[:1],       __lowerCamelCase       )

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_common()
    UpperCamelCase__			    =    True

    for model_class in self.all_model_classes:
       UpperCamelCase__			    =    True
       UpperCamelCase__			    =    False
       UpperCamelCase__			    =    True
       UpperCamelCase__			    =    model_class(__lowerCamelCase       )
       model.to(__lowerCamelCase       )
       model.eval()
       with torch.no_grad():
          UpperCamelCase__			    =    model(**self._prepare_for_class(__lowerCamelCase,       __lowerCamelCase       )       )
       UpperCamelCase__			    =    outputs.attentions
       UpperCamelCase__			    =    len(self.model_tester.depths       )
       self.assertEqual(len(__lowerCamelCase       ),       __lowerCamelCase       )

       # check that output_attentions also work using config
       del inputs_dict["output_attentions"]
       UpperCamelCase__			    =    True
       UpperCamelCase__			    =    config.window_size**2
       UpperCamelCase__			    =    model_class(__lowerCamelCase       )
       model.to(__lowerCamelCase       )
       model.eval()
       with torch.no_grad():
          UpperCamelCase__			    =    model(**self._prepare_for_class(__lowerCamelCase,       __lowerCamelCase       )       )
       UpperCamelCase__			    =    outputs.attentions
       self.assertEqual(len(__lowerCamelCase       ),       __lowerCamelCase       )

       self.assertListEqual(
           list(attentions[0].shape[-3:]       ),       [self.model_tester.num_heads[0], window_size_squared, window_size_squared],       )
       UpperCamelCase__			    =    len(__lowerCamelCase       )

       # Check attention is always last and order is fine
       UpperCamelCase__			    =    True
       UpperCamelCase__			    =    True
       UpperCamelCase__			    =    model_class(__lowerCamelCase       )
       model.to(__lowerCamelCase       )
       model.eval()
       with torch.no_grad():
          UpperCamelCase__			    =    model(**self._prepare_for_class(__lowerCamelCase,       __lowerCamelCase       )       )

       # also another +1 for reshaped_hidden_states
       UpperCamelCase__			    =    1 if model_class.__name__ == """SwinBackbone""" else 2
       self.assertEqual(out_len + added_hidden_states,       len(__lowerCamelCase       )       )

       UpperCamelCase__			    =    outputs.attentions

       self.assertEqual(len(__lowerCamelCase       ),       __lowerCamelCase       )

       self.assertListEqual(
           list(self_attentions[0].shape[-3:]       ),       [self.model_tester.num_heads[0], window_size_squared, window_size_squared],       )

 def 		lowercase_    (			self			:						Any,       a_			:						List[Any],       a_			:						Any,       a_			:						Dict,       a_			:						Optional[Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    model_class(__lowerCamelCase       )
    model.to(__lowerCamelCase       )
    model.eval()

    with torch.no_grad():
       UpperCamelCase__			    =    model(**self._prepare_for_class(__lowerCamelCase,       __lowerCamelCase       )       )

    UpperCamelCase__			    =    outputs.hidden_states

    UpperCamelCase__			    =    getattr(
        self.model_tester,       "expected_num_hidden_layers",       len(self.model_tester.depths       ) + 1       )
    self.assertEqual(len(__lowerCamelCase       ),       __lowerCamelCase       )

    # Swin has a different seq_length
    UpperCamelCase__			    =    (
        config.patch_size
        if isinstance(config.patch_size,       collections.abc.Iterable       )
        else (config.patch_size, config.patch_size)
    )

    UpperCamelCase__			    =    (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

    self.assertListEqual(
        list(hidden_states[0].shape[-2:]       ),       [num_patches, self.model_tester.embed_dim],       )

    if not model_class.__name__ == "SwinBackbone":
       UpperCamelCase__			    =    outputs.reshaped_hidden_states
       self.assertEqual(len(__lowerCamelCase       ),       __lowerCamelCase       )

       UpperCamelCase__			    =    reshaped_hidden_states[0].shape
       UpperCamelCase__			    =    (
           reshaped_hidden_states[0].view(__lowerCamelCase,       __lowerCamelCase,       height * width       ).permute(0,       2,       1       )
       )
       self.assertListEqual(
           list(reshaped_hidden_states.shape[-2:]       ),       [num_patches, self.model_tester.embed_dim],       )

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_common()

    UpperCamelCase__			    =    (
        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__			    =    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__			    =    True

       self.check_hidden_states_output(__lowerCamelCase,       __lowerCamelCase,       __lowerCamelCase,       __lowerCamelCase       )

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_common()
    UpperCamelCase__			    =    3

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

    UpperCamelCase__			    =    image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
    UpperCamelCase__			    =    image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

    for model_class in self.all_model_classes:
       UpperCamelCase__			    =    True
       self.check_hidden_states_output(__lowerCamelCase,       __lowerCamelCase,       __lowerCamelCase,       (padded_height, padded_width)       )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       UpperCamelCase__			    =    True
       self.check_hidden_states_output(__lowerCamelCase,       __lowerCamelCase,       __lowerCamelCase,       (padded_height, padded_width)       )

 @slow
 def 		lowercase_    (			self			:						Union[str, Any]       ):





    """simple docstring"""



    for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCamelCase__			    =    SwinModel.from_pretrained(__lowerCamelCase       )
       self.assertIsNotNone(__lowerCamelCase       )

 def 		lowercase_    (			self			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_common()

    UpperCamelCase__			    =    _config_zero_init(__lowerCamelCase       )
    for model_class in self.all_model_classes:
       UpperCamelCase__			    =    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_vision
@require_torch
class 			UpperCAmelCase			(							unittest.TestCase):

 @cached_property
 def 		lowercase_    (			self			:						str       ):





    """simple docstring"""



    return (
        AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224"       )
        if is_vision_available()
        else None
    )

 @slow
 def 		lowercase_    (			self			:						Dict       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224"       ).to(__lowerCamelCase       )
    UpperCamelCase__			    =    self.default_image_processor

    UpperCamelCase__			    =    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
    UpperCamelCase__			    =    image_processor(images=__lowerCamelCase,       return_tensors="pt"       ).to(__lowerCamelCase       )

    # forward pass
    with torch.no_grad():
       UpperCamelCase__			    =    model(**__lowerCamelCase       )

    # verify the logits
    UpperCamelCase__			    =    torch.Size((1, 1000)       )
    self.assertEqual(outputs.logits.shape,       __lowerCamelCase       )
    UpperCamelCase__			    =    torch.tensor([-0.0_948, -0.6_454, -0.0_921]       ).to(__lowerCamelCase       )
    self.assertTrue(torch.allclose(outputs.logits[0, :3],       __lowerCamelCase,       atol=1e-4       )       )







@require_torch
class 			UpperCAmelCase			(							unittest.TestCase		,      _a):
 _lowerCamelCase			:       List[str]            =       (SwinBackbone,) if is_torch_available() else ()
 _lowerCamelCase			:       Union[str, Any]            =       SwinConfig

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    UpperCamelCase__			    =    SwinModelTester(self       )







class        _SCREAMING_SNAKE_CASE			:





	def __init__(						self							:   Union[str, Any]      ):
		UpperCamelCase	:Union[str, Any]		=      [0, 1]





	def 		_A					(						self							:   str					,    __lowerCamelCase							:   int      ):
		if (difference := index - (len(self.sequence      ) - 2)) >= 1:
			for _ in range(__lowerCamelCase      ):
				self.sequence.append(self.sequence[-1] + self.sequence[-2]      )
		return self.sequence[:index]

def   SCREAMING_SNAKE_CASE_				(				)						->     None:






	"""simple docstring"""



	print(
	    """Fibonacci Series Using Dynamic Programming\n"""      ,     """Enter the index of the Fibonacci number you want to calculate """      ,     """in the prompt below. (To exit enter exit or Ctrl-C)\n"""      ,     sep=""""""      ,     )
	UpperCamelCase	:Any		=      Fibonacci()

	while True:
		UpperCamelCase	:str		=      input(""">> """   )
		if prompt in {"exit", "quit"}:
			break

		try:
			UpperCamelCase	:int		=      int(__magic_name__   )
		except ValueError:
			print("""Enter a number or 'exit'"""   )
			continue

		print(fibonacci.get(__magic_name__   )   )


if __name__ == "__main__":
	main()
