





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			:
			'''simple docstring'''




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







					"""simple docstring"""






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






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







					"""simple docstring"""






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

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

					A__        =   self.get_config()

					return config, pixel_values, labels






			def    a_       (			self   :    Optional[int]   )	->	Any:







					"""simple docstring"""






					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    a_       (			self   :    Tuple							,	__lowerCAmelCase   :    Optional[int]							,	__lowerCAmelCase   :    Dict							,	__lowerCAmelCase   :    List[str]   )	->	List[str]:







					"""simple docstring"""






					A__        =   MaskFormerSwinModel(config=__lowerCAmelCase   )
					model.to(__lowerCAmelCase   )
					model.eval()
					A__        =   model(__lowerCAmelCase   )

					A__        =   ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
					A__        =   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    a_       (			self   :    List[Any]							,	__lowerCAmelCase   :    List[str]							,	__lowerCAmelCase   :    Optional[Any]							,	__lowerCAmelCase   :    Optional[Any]   )	->	Any:







					"""simple docstring"""






					A__        =   MaskFormerSwinBackbone(config=__lowerCAmelCase   )
					model.to(__lowerCAmelCase   )
					model.eval()
					A__        =   model(__lowerCAmelCase   )

					# 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(__lowerCAmelCase   ):
							A__        =   ["""stem"""]
							A__        =   MaskFormerSwinBackbone(config=__lowerCAmelCase   )







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







					"""simple docstring"""






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


@require_torch
class   A			(SCREAMING_SNAKE_CASE   ,     SCREAMING_SNAKE_CASE   ,     unittest.TestCase    ):
			'''simple docstring'''




			__lowerCamelCase	:       List[Any]							=    (
			    (
			        MaskFormerSwinModel,
			        MaskFormerSwinBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			__lowerCamelCase	:       Tuple							=    {'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {}
			__lowerCamelCase	:       Optional[int]							=    False
			__lowerCamelCase	:       List[str]							=    False
			__lowerCamelCase	:       Optional[Any]							=    False
			__lowerCamelCase	:       Union[str, Any]							=    False
			__lowerCamelCase	:       Tuple							=    False






			def    a_       (			self   :    Any   )	->	Any:







					"""simple docstring"""






					A__        =   MaskFormerSwinModelTester(self   )
					A__        =   ConfigTester(self							,	config_class=__lowerCAmelCase							,	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    a_       (			self   :    Union[str, Any]   )	->	Dict:







					"""simple docstring"""






					pass






			def    a_       (			self   :    Dict   )	->	Optional[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    a_       (			self   :    int   )	->	Optional[Any]:







					"""simple docstring"""






					return






			def    a_       (			self   :    int   )	->	str:







					"""simple docstring"""






					A__        =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__lowerCAmelCase   )






			def    a_       (			self   :    Optional[int]   )	->	Any:







					"""simple docstring"""






					A__        =   self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*__lowerCAmelCase   )






			@unittest.skip("""Swin does not use inputs_embeds"""   )
			def    a_       (			self   :    List[Any]   )	->	List[str]:







					"""simple docstring"""






					pass






			@unittest.skip("""Swin does not support feedforward chunking"""   )
			def    a_       (			self   :    Dict   )	->	List[Any]:







					"""simple docstring"""






					pass






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







					"""simple docstring"""






					A__      ,			A__        =   self.model_tester.prepare_config_and_inputs_for_common()

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






			def    a_       (			self   :    Dict   )	->	Any:







					"""simple docstring"""






					A__      ,			A__        =   self.model_tester.prepare_config_and_inputs_for_common()

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

							A__        =   ["""pixel_values"""]
							self.assertListEqual(arg_names[:1]							,	__lowerCAmelCase   )






			@unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn't support output_attentions"""   )
			def    a_       (			self   :    int   )	->	Union[str, Any]:







					"""simple docstring"""






					pass






			@unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""   )
			def    a_       (			self   :    Union[str, Any]   )	->	Union[str, Any]:







					"""simple docstring"""






					pass






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







					"""simple docstring"""






					A__        =   model_class(__lowerCAmelCase   )
					model.to(__lowerCAmelCase   )
					model.eval()

					with torch.no_grad():
							A__        =   model(**self._prepare_for_class(__lowerCAmelCase							,	__lowerCAmelCase   )   )

					A__        =   outputs.hidden_states

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

					A__        =   (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    a_       (			self   :    List[str]   )	->	Any:







					"""simple docstring"""






					A__      ,			A__        =   self.model_tester.prepare_config_and_inputs_for_common()

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

							self.check_hidden_states_output(__lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase   )






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







					"""simple docstring"""






					A__      ,			A__        =   self.model_tester.prepare_config_and_inputs_for_common()
					A__        =   3

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

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

					for model_class in self.all_model_classes:
							A__        =   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"]
							A__        =   True
							self.check_hidden_states_output(__lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase							,	(padded_height, padded_width)   )






			@unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""   )
			def    a_       (			self   :    str   )	->	Optional[int]:







					"""simple docstring"""






					pass






			@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""   )
			def    a_       (			self   :    List[Any]   )	->	Union[str, Any]:







					"""simple docstring"""






					pass






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







					"""simple docstring"""






					pass







			def    a_       (			self   :    Tuple   )	->	Dict:







					"""simple docstring"""






					A__      ,			A__        =   self.model_tester.prepare_config_and_inputs_for_common()

					def set_nan_tensor_to_zero(__lowerCAmelCase   :    str   ):
							A__        =   0
							return t

					def check_equivalence(__lowerCAmelCase   :    Any							,	__lowerCAmelCase   :    Optional[Any]							,	__lowerCAmelCase   :    Optional[int]							,	__lowerCAmelCase   :    str={}   ):
							with torch.no_grad():
									A__        =   model(**__lowerCAmelCase							,	return_dict=__lowerCAmelCase							,	**__lowerCAmelCase   )
									A__        =   model(**__lowerCAmelCase							,	return_dict=__lowerCAmelCase							,	**__lowerCAmelCase   ).to_tuple()

									def recursive_check(__lowerCAmelCase   :    Union[str, Any]							,	__lowerCAmelCase   :    int   ):
											if isinstance(__lowerCAmelCase							,	(List, Tuple)   ):
													for tuple_iterable_value, dict_iterable_value in zip(__lowerCAmelCase							,	__lowerCAmelCase   ):
															recursive_check(__lowerCAmelCase							,	__lowerCAmelCase   )
											elif isinstance(__lowerCAmelCase							,	__lowerCAmelCase   ):
													for tuple_iterable_value, dict_iterable_value in zip(
													    tuple_object.values()							,	dict_object.values()   ):
															recursive_check(__lowerCAmelCase							,	__lowerCAmelCase   )
											elif tuple_object is None:
													return
											else:
													self.assertTrue(
													    torch.allclose(
													        set_nan_tensor_to_zero(__lowerCAmelCase   )							,	set_nan_tensor_to_zero(__lowerCAmelCase   )							,	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(__lowerCAmelCase   ).any()} and `inf`: {torch.isinf(__lowerCAmelCase   )}. Dict has'
													        f' `nan`: {torch.isnan(__lowerCAmelCase   ).any()} and `inf`: {torch.isinf(__lowerCAmelCase   )}.'
													    )							,	)

									recursive_check(__lowerCAmelCase							,	__lowerCAmelCase   )

					for model_class in self.all_model_classes:
							A__        =   model_class(__lowerCAmelCase   )
							model.to(__lowerCAmelCase   )
							model.eval()

							A__        =   self._prepare_for_class(__lowerCAmelCase							,	__lowerCAmelCase   )
							A__        =   self._prepare_for_class(__lowerCAmelCase							,	__lowerCAmelCase   )
							check_equivalence(__lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase   )

							A__        =   self._prepare_for_class(__lowerCAmelCase							,	__lowerCAmelCase							,	return_labels=__lowerCAmelCase   )
							A__        =   self._prepare_for_class(__lowerCAmelCase							,	__lowerCAmelCase							,	return_labels=__lowerCAmelCase   )
							check_equivalence(__lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase   )

							A__        =   self._prepare_for_class(__lowerCAmelCase							,	__lowerCAmelCase   )
							A__        =   self._prepare_for_class(__lowerCAmelCase							,	__lowerCAmelCase   )
							check_equivalence(__lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase							,	{"""output_hidden_states""": True}   )

							A__        =   self._prepare_for_class(__lowerCAmelCase							,	__lowerCAmelCase							,	return_labels=__lowerCAmelCase   )
							A__        =   self._prepare_for_class(__lowerCAmelCase							,	__lowerCAmelCase							,	return_labels=__lowerCAmelCase   )
							check_equivalence(__lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase							,	{"""output_hidden_states""": True}   )


@require_torch
class   A			(unittest.TestCase   ,     SCREAMING_SNAKE_CASE    ):
			'''simple docstring'''




			__lowerCamelCase	:       Tuple							=    (MaskFormerSwinBackbone,) if is_torch_available() else ()
			__lowerCamelCase	:       Optional[Any]							=    MaskFormerSwinConfig






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







					"""simple docstring"""






					A__        =   MaskFormerSwinModelTester(self   )







			def    a_       (			self   :    Dict   )	->	int:







					"""simple docstring"""






					A__      ,			A__        =   self.model_tester.prepare_config_and_inputs_for_common()
					A__        =   inputs_dict["""pixel_values"""].shape[0]

					for backbone_class in self.all_model_classes:
							A__        =   backbone_class(__lowerCAmelCase   )
							backbone.to(__lowerCAmelCase   )
							backbone.eval()

							A__        =   backbone(**__lowerCAmelCase   )

							# Test default outputs and verify feature maps
							self.assertIsInstance(outputs.feature_maps							,	__lowerCAmelCase   )
							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
							A__        =   backbone(**__lowerCAmelCase							,	output_hidden_states=__lowerCAmelCase   )
							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)
											A__      ,			A__      ,			A__        =   hidden_state.shape
											self.assertTrue((h_batch_size, h_n_channels)							,	(batch_size, n_channels)   )

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










from math import ceil







def    __lowerCamelCase					(							__a   :int = 1_0_0_1    )		->				int:






		"""simple docstring"""

		A__        =   1

		for i in range(1    ,     int(ceil(n / 2.0    )    )    ):
				A__        =   2 * i + 1
				A__        =   2 * i
				A__        =   total + 4 * odd**2 - 6 * even

		return total


if __name__ == "__main__":
					import sys

					if len(sys.argv) == 1:
										print(solution())
					else:
										try:
															A    :					List[str] =      int(sys.argv[1])
															print(solution(n))
										except ValueError:
															print('''Invalid entry - please enter a number''')



