"""simple docstring"""




import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import MaskFormerSwinBackbone
			from transformers.models.maskformer import MaskFormerSwinModel

class       a_      :




					def __init__(	self						:     int  ,						snake_case__						:     Any  ,						snake_case__						:     List[str]=13  ,						snake_case__						:     int=32  ,						snake_case__						:     Dict=2  ,						snake_case__						:     Optional[Any]=3  ,						snake_case__						:     Optional[Any]=16  ,						snake_case__						:     Tuple=[1, 2, 1]  ,						snake_case__						:     Optional[int]=[2, 2, 4]  ,						snake_case__						:     Union[str, Any]=2  ,						snake_case__						:     List[Any]=2.0  ,						snake_case__						:     List[str]=True  ,						snake_case__						:     Optional[int]=0.0  ,						snake_case__						:     Dict=0.0  ,						snake_case__						:     Tuple=0.1  ,						snake_case__						:     List[str]="gelu"  ,						snake_case__						:     int=False  ,						snake_case__						:     List[str]=True  ,						snake_case__						:     List[Any]=0.02  ,						snake_case__						:     Tuple=1E-5  ,						snake_case__						:     Union[str, Any]=True  ,						snake_case__						:     str=None  ,						snake_case__						:     List[Any]=True  ,						snake_case__						:     str=10  ,						snake_case__						:     Dict=8  ,						snake_case__						:     List[Any]=["stage1", "stage2", "stage3"]  ,						snake_case__						:     List[str]=[1, 2, 3]  ,						):
							lowerCAmelCase__        =   parent
							lowerCAmelCase__        =   batch_size
							lowerCAmelCase__        =   image_size
							lowerCAmelCase__        =   patch_size
							lowerCAmelCase__        =   num_channels
							lowerCAmelCase__        =   embed_dim
							lowerCAmelCase__        =   depths
							lowerCAmelCase__        =   num_heads
							lowerCAmelCase__        =   window_size
							lowerCAmelCase__        =   mlp_ratio
							lowerCAmelCase__        =   qkv_bias
							lowerCAmelCase__        =   hidden_dropout_prob
							lowerCAmelCase__        =   attention_probs_dropout_prob
							lowerCAmelCase__        =   drop_path_rate
							lowerCAmelCase__        =   hidden_act
							lowerCAmelCase__        =   use_absolute_embeddings
							lowerCAmelCase__        =   patch_norm
							lowerCAmelCase__        =   layer_norm_eps
							lowerCAmelCase__        =   initializer_range
							lowerCAmelCase__        =   is_training
							lowerCAmelCase__        =   scope
							lowerCAmelCase__        =   use_labels
							lowerCAmelCase__        =   type_sequence_label_size
							lowerCAmelCase__        =   encoder_stride
							lowerCAmelCase__        =   out_features
							lowerCAmelCase__        =   out_indices




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							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.type_sequence_label_size     )

							lowerCAmelCase__        =   self.get_config()

							return config, pixel_values, labels




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							return MaskFormerSwinConfig(
							    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 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]  ,						snake_case__						:     Tuple  ,						snake_case__						:     Any  ,						snake_case__						:     Any     ):
							lowerCAmelCase__        =   MaskFormerSwinModel(config=snake_case__     )
							model.to(snake_case__     )
							model.eval()
							lowerCAmelCase__        =   model(snake_case__     )

							lowerCAmelCase__        =   ((config.image_size // config.patch_size) ** 2) // (4 ** (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_seq_len, expected_dim)     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]  ,						snake_case__						:     Union[str, Any]  ,						snake_case__						:     str  ,						snake_case__						:     Optional[int]     ):
							lowerCAmelCase__        =   MaskFormerSwinBackbone(config=snake_case__     )
							model.to(snake_case__     )
							model.eval()
							lowerCAmelCase__        =   model(snake_case__     )

							# verify feature maps
							self.parent.assertEqual(len(result.feature_maps     )  ,						len(config.out_features     )     )
							self.parent.assertListEqual(list(result.feature_maps[0].shape     )  ,						[13, 16, 16, 16]     )

							# verify channels
							self.parent.assertEqual(len(model.channels     )  ,						len(config.out_features     )     )
							self.parent.assertListEqual(model.channels  ,						[16, 32, 64]     )

							# verify ValueError
							with self.parent.assertRaises(snake_case__     ):
									lowerCAmelCase__        =   ["""stem"""]
									lowerCAmelCase__        =   MaskFormerSwinBackbone(config=snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   self.prepare_config_and_inputs()
							lowerCAmelCase__   ,					lowerCAmelCase__   ,					lowerCAmelCase__        =   config_and_inputs
							lowerCAmelCase__        =   {"""pixel_values""": pixel_values}
							return config, inputs_dict

@require_torch
class       a_      (     __UpperCamelCase ,		__UpperCamelCase ,		unittest.TestCase			):
					UpperCamelCase_ :	Optional[int]			=    (
					    (
					        MaskFormerSwinModel,
					        MaskFormerSwinBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					UpperCamelCase_ :	str			=    {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
					UpperCamelCase_ :	Optional[Any]			=    False
					UpperCamelCase_ :	List[Any]			=    False
					UpperCamelCase_ :	Optional[Any]			=    False
					UpperCamelCase_ :	Optional[int]			=    False
					UpperCamelCase_ :	Dict			=    False




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							lowerCAmelCase__        =   MaskFormerSwinModelTester(self     )
							lowerCAmelCase__        =   ConfigTester(self  ,						config_class=snake_case__  ,						embed_dim=37     )




					@require_torch_multi_gpu
					@unittest.skip(
					    reason=(
					        """`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with"""
					        """ `nn.DataParallel`"""
					    )     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							pass




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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*snake_case__     )




					@unittest.skip("""Swin does not use inputs_embeds"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							pass




					@unittest.skip("""Swin does not support feedforward chunking"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Union[str, Any]     ):
							pass




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							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 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							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__     )




					@unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn't support output_attentions"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							pass




					@unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							pass




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]  ,						snake_case__						:     Optional[Any]  ,						snake_case__						:     Dict  ,						snake_case__						:     Optional[Any]  ,						snake_case__						:     Any     ):
							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__     )

							# Swin 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[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]  ,						)




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							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__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCAmelCase__        =   3

							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)
							)
							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] - (image_size[0] % patch_size[0])
							lowerCAmelCase__        =   image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

							for model_class in self.all_model_classes:
									lowerCAmelCase__        =   True
									self.check_hidden_states_output(snake_case__  ,						snake_case__  ,						snake_case__  ,						(padded_height, padded_width)     )

									# 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__  ,						(padded_height, padded_width)     )




					@unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Union[str, Any]     ):
							pass




					@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							pass




					@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							pass




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()

							def set_nan_tensor_to_zero(snake_case__						:     Union[str, Any]     ):
									lowerCAmelCase__        =   0
									return t

							def check_equivalence(snake_case__						:     List[str]  ,						snake_case__						:     Any  ,						snake_case__						:     Dict  ,						snake_case__						:     int={}     ):
									with torch.no_grad():
											lowerCAmelCase__        =   model(**snake_case__  ,						return_dict=snake_case__  ,						**snake_case__     )
											lowerCAmelCase__        =   model(**snake_case__  ,						return_dict=snake_case__  ,						**snake_case__     ).to_tuple()

											def recursive_check(snake_case__						:     Dict  ,						snake_case__						:     int     ):
													if isinstance(snake_case__  ,						(List, Tuple)     ):
															for tuple_iterable_value, dict_iterable_value in zip(snake_case__  ,						snake_case__     ):
																	recursive_check(snake_case__  ,						snake_case__     )
													elif isinstance(snake_case__  ,						snake_case__     ):
															for tuple_iterable_value, dict_iterable_value in zip(
															    tuple_object.values()  ,						dict_object.values()     ):
																	recursive_check(snake_case__  ,						snake_case__     )
													elif tuple_object is None:
															return
													else:
															self.assertTrue(
															    torch.allclose(
															        set_nan_tensor_to_zero(snake_case__     )  ,						set_nan_tensor_to_zero(snake_case__     )  ,						atol=1E-5     )  ,						msg=(
															        """Tuple and dict output are not equal. Difference:"""
															        F""" {torch.max(torch.abs(tuple_object - dict_object     )     )}. Tuple has `nan`:"""
															        F""" {torch.isnan(snake_case__     ).any()} and `inf`: {torch.isinf(snake_case__     )}. Dict has"""
															        F""" `nan`: {torch.isnan(snake_case__     ).any()} and `inf`: {torch.isinf(snake_case__     )}."""
															    )  ,						)

											recursive_check(snake_case__  ,						snake_case__     )

							for model_class in self.all_model_classes:
									lowerCAmelCase__        =   model_class(snake_case__     )
									model.to(snake_case__     )
									model.eval()

									lowerCAmelCase__        =   self._prepare_for_class(snake_case__  ,						snake_case__     )
									lowerCAmelCase__        =   self._prepare_for_class(snake_case__  ,						snake_case__     )
									check_equivalence(snake_case__  ,						snake_case__  ,						snake_case__     )

									lowerCAmelCase__        =   self._prepare_for_class(snake_case__  ,						snake_case__  ,						return_labels=snake_case__     )
									lowerCAmelCase__        =   self._prepare_for_class(snake_case__  ,						snake_case__  ,						return_labels=snake_case__     )
									check_equivalence(snake_case__  ,						snake_case__  ,						snake_case__     )

									lowerCAmelCase__        =   self._prepare_for_class(snake_case__  ,						snake_case__     )
									lowerCAmelCase__        =   self._prepare_for_class(snake_case__  ,						snake_case__     )
									check_equivalence(snake_case__  ,						snake_case__  ,						snake_case__  ,						{"""output_hidden_states""": True}     )

									lowerCAmelCase__        =   self._prepare_for_class(snake_case__  ,						snake_case__  ,						return_labels=snake_case__     )
									lowerCAmelCase__        =   self._prepare_for_class(snake_case__  ,						snake_case__  ,						return_labels=snake_case__     )
									check_equivalence(snake_case__  ,						snake_case__  ,						snake_case__  ,						{"""output_hidden_states""": True}     )

@require_torch
class       a_      (     unittest.TestCase ,		__UpperCamelCase			):
					UpperCamelCase_ :	Optional[int]			=    (MaskFormerSwinBackbone,) if is_torch_available() else ()
					UpperCamelCase_ :	Optional[Any]			=    MaskFormerSwinConfig




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   MaskFormerSwinModelTester(self     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()
							lowerCAmelCase__        =   inputs_dict["""pixel_values"""].shape[0]

							for backbone_class in self.all_model_classes:
									lowerCAmelCase__        =   backbone_class(snake_case__     )
									backbone.to(snake_case__     )
									backbone.eval()

									lowerCAmelCase__        =   backbone(**snake_case__     )

									# Test default outputs and verify feature maps
									self.assertIsInstance(outputs.feature_maps  ,						snake_case__     )
									self.assertTrue(len(outputs.feature_maps     ) == len(backbone.channels     )     )
									for feature_map, n_channels in zip(outputs.feature_maps  ,						backbone.channels     ):
											self.assertTrue(feature_map.shape[:2]  ,						(batch_size, n_channels)     )
									self.assertIsNone(outputs.hidden_states     )
									self.assertIsNone(outputs.attentions     )

									# Test output_hidden_states=True
									lowerCAmelCase__        =   backbone(**snake_case__  ,						output_hidden_states=snake_case__     )
									self.assertIsNotNone(outputs.hidden_states     )
									self.assertTrue(len(outputs.hidden_states     )  ,						len(backbone.stage_names     )     )
									# We skip the stem layer
									for hidden_states, n_channels in zip(outputs.hidden_states[1:]  ,						backbone.channels     ):
											for hidden_state in hidden_states:
													# Hidden states are in the format (batch_size, (height * width), n_channels)
													lowerCAmelCase__   ,					lowerCAmelCase__   ,					lowerCAmelCase__        =   hidden_state.shape
													self.assertTrue((h_batch_size, h_n_channels)  ,						(batch_size, n_channels)     )

            # Test output_attentions=True
									if self.has_attentions:
											lowerCAmelCase__        =   backbone(**snake_case__  ,						output_attentions=snake_case__     )
											self.assertIsNotNone(outputs.attentions     )




"""simple docstring"""




def 							_UpperCAmelCase		(       lowerCamelCase__     ):





		"""simple docstring"""




		assert isinstance(lowerCamelCase__			,  lowerCamelCase__     ), f"""The input value of [n={number}] is not an integer"""

		if number == 1:
				return 2
		elif number < 1:
				lowerCAmelCase__        =   f"""The input value of [n={number}] has to be > 0"""
				raise ValueError(lowerCamelCase__     )
		else:
				lowerCAmelCase__        =   sylvester(number - 1     )
				lowerCAmelCase__        =   num - 1
				lowerCAmelCase__        =   num
				return lower * upper + 1


if __name__ == "__main__":
			print(F"The 8th number in Sylvester's sequence: {sylvester(8)}")




