

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






					"""simple docstring"""



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







					def  __lowerCAmelCase				( self    :       str	):
						lowerCAmelCase__			:		List[str]						       =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

						lowerCAmelCase__			:		Dict						       =			None
						if self.use_labels:
							lowerCAmelCase__			:		Union[str, Any]						       =			ids_tensor([self.batch_size]     ,self.type_sequence_label_size	)

						lowerCAmelCase__			:		str						       =			self.get_config()

						return config, pixel_values, labels







					def  __lowerCAmelCase				( self    :       Dict	):
						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  __lowerCAmelCase				( self    :       Union[str, Any]     ,lowercase_    :       Optional[Any]     ,lowercase_    :       List[Any]     ,lowercase_    :       Dict	):
						lowerCAmelCase__			:		Optional[int]						       =			SwinModel(config=lowercase_	)
						model.to(lowercase_	)
						model.eval()
						lowerCAmelCase__			:		Optional[int]						       =			model(lowercase_	)

						lowerCAmelCase__			:		Dict						       =			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
						lowerCAmelCase__			:		Optional[Any]						       =			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  __lowerCAmelCase				( self    :       Tuple     ,lowercase_    :       Dict     ,lowercase_    :       Optional[Any]     ,lowercase_    :       Union[str, Any]	):
						lowerCAmelCase__			:		List[Any]						       =			SwinBackbone(config=lowercase_	)
						model.to(lowercase_	)
						model.eval()
						lowerCAmelCase__			:		Optional[int]						       =			model(lowercase_	)

						# 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
						lowerCAmelCase__			:		List[Any]						       =			None
						lowerCAmelCase__			:		Union[str, Any]						       =			SwinBackbone(config=lowercase_	)
						model.to(lowercase_	)
						model.eval()
						lowerCAmelCase__			:		Dict						       =			model(lowercase_	)

						# 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    :       Union[str, Any]     ,lowercase_    :       int     ,lowercase_    :       Optional[int]     ,lowercase_    :       List[str]	):
						lowerCAmelCase__			:		Optional[int]						       =			SwinForMaskedImageModeling(config=lowercase_	)
						model.to(lowercase_	)
						model.eval()
						lowerCAmelCase__			:		List[Any]						       =			model(lowercase_	)
						self.parent.assertEqual(
						    result.logits.shape     ,(self.batch_size, self.num_channels, self.image_size, self.image_size)	)

						# test greyscale images
						lowerCAmelCase__			:		Any						       =			1
						lowerCAmelCase__			:		Any						       =			SwinForMaskedImageModeling(lowercase_	)
						model.to(lowercase_	)
						model.eval()

						lowerCAmelCase__			:		str						       =			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
						lowerCAmelCase__			:		Optional[Any]						       =			model(lowercase_	)
						self.parent.assertEqual(result.logits.shape     ,(self.batch_size, 1, self.image_size, self.image_size)	)







					def  __lowerCAmelCase				( self    :       Dict     ,lowercase_    :       Optional[Any]     ,lowercase_    :       List[Any]     ,lowercase_    :       Optional[int]	):
						lowerCAmelCase__			:		Optional[Any]						       =			self.type_sequence_label_size
						lowerCAmelCase__			:		Any						       =			SwinForImageClassification(lowercase_	)
						model.to(lowercase_	)
						model.eval()
						lowerCAmelCase__			:		str						       =			model(lowercase_     ,labels=lowercase_	)
						self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.type_sequence_label_size)	)

						# test greyscale images
						lowerCAmelCase__			:		List[Any]						       =			1
						lowerCAmelCase__			:		Dict						       =			SwinForImageClassification(lowercase_	)
						model.to(lowercase_	)
						model.eval()

						lowerCAmelCase__			:		Union[str, Any]						       =			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
						lowerCAmelCase__			:		str						       =			model(lowercase_	)
						self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.type_sequence_label_size)	)







					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__			:		Dict						       =			self.prepare_config_and_inputs()
						(
						    (
						    lowerCAmelCase__
						)       ,(
						    lowerCAmelCase__
						)       ,(
						    lowerCAmelCase__
						)       ,
						)			:		Union[str, Any]						       =			config_and_inputs
						lowerCAmelCase__			:		Dict						       =			{'''pixel_values''': pixel_values}
						return config, inputs_dict







@require_torch
class        SCREAMING_SNAKE_CASE      (	a_					,							a_					,							unittest.TestCase ):






					"""simple docstring"""



					lowercase__       				= (
					    (
					        SwinModel,
					        SwinBackbone,
					        SwinForImageClassification,
					        SwinForMaskedImageModeling,
					    )
					    if is_torch_available()
					    else ()
					)
					lowercase__       				= (
					    {"feature-extraction": SwinModel, "image-classification": SwinForImageClassification}
					    if is_torch_available()
					    else {}
					)
					lowercase__       				= True

					lowercase__       				= False
					lowercase__       				= False
					lowercase__       				= False







					def  __lowerCAmelCase				( self    :       Optional[Any]	):
						lowerCAmelCase__			:		List[str]						       =			SwinModelTester(self	)
						lowerCAmelCase__			:		str						       =			ConfigTester(self     ,config_class=lowercase_     ,embed_dim=3_7	)







					def  __lowerCAmelCase				( self    :       int	):
						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    :       Dict	):
						return







					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__			:		int						       =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowercase_	)







					@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''	)
					def  __lowerCAmelCase				( self    :       List[Any]	):
						pass







					def  __lowerCAmelCase				( self    :       Optional[Any]	):
						super().test_training_gradient_checkpointing()







					def  __lowerCAmelCase				( self    :       int	):
						lowerCAmelCase__			:		Optional[Any]						       =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_backbone(*lowercase_	)







					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__			:		int						       =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_image_modeling(*lowercase_	)







					def  __lowerCAmelCase				( self    :       Optional[int]	):
						lowerCAmelCase__			:		int						       =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*lowercase_	)







					@unittest.skip(reason='''Swin does not use inputs_embeds'''	)
					def  __lowerCAmelCase				( self    :       List[Any]	):
						pass







					@unittest.skip(reason='''Swin Transformer does not use feedforward chunking'''	)
					def  __lowerCAmelCase				( self    :       Optional[Any]	):
						pass







					def  __lowerCAmelCase				( self    :       List[Any]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[Any]						       =			self.model_tester.prepare_config_and_inputs_for_common()

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







					def  __lowerCAmelCase				( self    :       List[str]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		List[str]						       =			self.model_tester.prepare_config_and_inputs_for_common()

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

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







					def  __lowerCAmelCase				( self    :       Dict	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Tuple						       =			self.model_tester.prepare_config_and_inputs_for_common()
						lowerCAmelCase__			:		Any						       =			True

						for model_class in self.all_model_classes:
							lowerCAmelCase__			:		Any						       =			True
							lowerCAmelCase__			:		int						       =			False
							lowerCAmelCase__			:		str						       =			True
							lowerCAmelCase__			:		Union[str, Any]						       =			model_class(lowercase_	)
							model.to(lowercase_	)
							model.eval()
							with torch.no_grad():
								lowerCAmelCase__			:		Dict						       =			model(**self._prepare_for_class(lowercase_     ,lowercase_	)	)
							lowerCAmelCase__			:		List[str]						       =			outputs.attentions
							lowerCAmelCase__			:		str						       =			len(self.model_tester.depths	)
							self.assertEqual(len(lowercase_	)     ,lowercase_	)

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

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

							# Check attention is always last and order is fine
							lowerCAmelCase__			:		str						       =			True
							lowerCAmelCase__			:		List[Any]						       =			True
							lowerCAmelCase__			:		Dict						       =			model_class(lowercase_	)
							model.to(lowercase_	)
							model.eval()
							with torch.no_grad():
								lowerCAmelCase__			:		Union[str, Any]						       =			model(**self._prepare_for_class(lowercase_     ,lowercase_	)	)

							# also another +1 for reshaped_hidden_states
							lowerCAmelCase__			:		Union[str, Any]						       =			1 if model_class.__name__ == '''SwinBackbone''' else 2
							self.assertEqual(out_len + added_hidden_states     ,len(lowercase_	)	)

							lowerCAmelCase__			:		Any						       =			outputs.attentions

							self.assertEqual(len(lowercase_	)     ,lowercase_	)

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







					def  __lowerCAmelCase				( self    :       Any     ,lowercase_    :       List[str]     ,lowercase_    :       List[str]     ,lowercase_    :       str     ,lowercase_    :       Optional[int]	):
						lowerCAmelCase__			:		str						       =			model_class(lowercase_	)
						model.to(lowercase_	)
						model.eval()

						with torch.no_grad():
							lowerCAmelCase__			:		List[Any]						       =			model(**self._prepare_for_class(lowercase_     ,lowercase_	)	)

						lowerCAmelCase__			:		Dict						       =			outputs.hidden_states

						lowerCAmelCase__			:		str						       =			getattr(
						    self.model_tester     ,'''expected_num_hidden_layers'''     ,len(self.model_tester.depths	) + 1	)
						self.assertEqual(len(lowercase_	)     ,lowercase_	)

						# Swin has a different seq_length
						lowerCAmelCase__			:		Optional[int]						       =			(
						    config.patch_size
						    if isinstance(config.patch_size     ,collections.abc.Iterable	)
						    else (config.patch_size, config.patch_size)
						)

						lowerCAmelCase__			:		Any						       =			(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":
							lowerCAmelCase__			:		Tuple						       =			outputs.reshaped_hidden_states
							self.assertEqual(len(lowercase_	)     ,lowercase_	)

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







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

						lowerCAmelCase__			:		Optional[Any]						       =			(
						    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__			:		Dict						       =			True
							self.check_hidden_states_output(lowercase_     ,lowercase_     ,lowercase_     ,lowercase_	)

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							lowerCAmelCase__			:		Dict						       =			True

							self.check_hidden_states_output(lowercase_     ,lowercase_     ,lowercase_     ,lowercase_	)







					def  __lowerCAmelCase				( self    :       Any	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Tuple						       =			self.model_tester.prepare_config_and_inputs_for_common()
						lowerCAmelCase__			:		Optional[int]						       =			3

						lowerCAmelCase__			:		List[str]						       =			(
						    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__			:		Dict						       =			(
						    config.patch_size
						    if isinstance(config.patch_size     ,collections.abc.Iterable	)
						    else (config.patch_size, config.patch_size)
						)

						lowerCAmelCase__			:		Dict						       =			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
						lowerCAmelCase__			:		Tuple						       =			image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

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

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							lowerCAmelCase__			:		List[Any]						       =			True
							self.check_hidden_states_output(lowercase_     ,lowercase_     ,lowercase_     ,(padded_height, padded_width)	)







					@slow
					def  __lowerCAmelCase				( self    :       Tuple	):
						for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							lowerCAmelCase__			:		Dict						       =			SwinModel.from_pretrained(lowercase_	)
							self.assertIsNotNone(lowercase_	)







					def  __lowerCAmelCase				( self    :       Optional[int]	):
						lowerCAmelCase__       ,lowerCAmelCase__			:		Tuple						       =			self.model_tester.prepare_config_and_inputs_for_common()

						lowerCAmelCase__			:		Union[str, Any]						       =			_config_zero_init(lowercase_	)
						for model_class in self.all_model_classes:
							lowerCAmelCase__			:		Union[str, Any]						       =			model_class(config=lowercase_	)
							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        SCREAMING_SNAKE_CASE      (	unittest.TestCase ):






					"""simple docstring"""



					@cached_property
					def  __lowerCAmelCase				( self    :       str	):
						return (
						    AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''	)
						    if is_vision_available()
						    else None
						)







					@slow
					def  __lowerCAmelCase				( self    :       Any	):
						lowerCAmelCase__			:		Union[str, Any]						       =			SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''	).to(lowercase_	)
						lowerCAmelCase__			:		Optional[Any]						       =			self.default_image_processor

						lowerCAmelCase__			:		Optional[int]						       =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
						lowerCAmelCase__			:		Union[str, Any]						       =			image_processor(images=lowercase_     ,return_tensors='''pt'''	).to(lowercase_	)

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

						# verify the logits
						lowerCAmelCase__			:		int						       =			torch.Size((1, 1_0_0_0)	)
						self.assertEqual(outputs.logits.shape     ,lowercase_	)
						lowerCAmelCase__			:		int						       =			torch.tensor([-0.0948, -0.6454, -0.0921]	).to(lowercase_	)
						self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,lowercase_     ,atol=1E-4	)	)







@require_torch
class        SCREAMING_SNAKE_CASE      (	unittest.TestCase					,							a_ ):






					"""simple docstring"""



					lowercase__       				= (SwinBackbone,) if is_torch_available() else ()
					lowercase__       				= SwinConfig







					def  __lowerCAmelCase				( self    :       Union[str, Any]	):
						lowerCAmelCase__			:		List[Any]						       =			SwinModelTester(self	)







"""simple docstring"""





from itertools import permutations

def 						__SCREAMING_SNAKE_CASE						(   A_ = 5				):
	if gon_side < 3 or gon_side > 5:
		raise ValueError('''gon_side must be in the range [3, 5]'''				)

	# Since it's 16, we know 10 is on the outer ring
	# Put the big numbers at the end so that they are never the first number
	lowerCAmelCase__			:		str						       =			list(range(gon_side + 1		,  0		,  -1				)				)
	lowerCAmelCase__			:		int						       =			list(range(gon_side + 2		,  gon_side * 2 + 1				)				)

	for perm in permutations(small_numbers + big_numbers				):
		lowerCAmelCase__			:		Optional[Any]						       =			generate_gon_ring(A_		,  list(A_				)				)
		if is_magic_gon(A_				):
			return int(''''''.join(str(A_				) for n in numbers				)				)

	lowerCAmelCase__			:		Tuple						       =			f'Magic {gon_side}-gon ring is impossible'
	raise ValueError(A_				)

def 						__SCREAMING_SNAKE_CASE						(   A_		,  A_				):
	lowerCAmelCase__			:		Dict						       =			[0] * (gon_side * 3)
	lowerCAmelCase__			:		Optional[int]						       =			perm[0:3]
	perm.append(perm[1]				)

	lowerCAmelCase__			:		int						       =			1 if gon_side < 5 else 2

	for i in range(1		,  len(A_				) // 3 + magic_number				):
		lowerCAmelCase__			:		List[str]						       =			perm[2 * i + 1]
		lowerCAmelCase__			:		Optional[int]						       =			result[3 * i - 1]
		lowerCAmelCase__			:		List[Any]						       =			perm[2 * i + 2]

	return result

def 						__SCREAMING_SNAKE_CASE						(   A_				):
	if len(A_				) % 3 != 0:
		raise ValueError('''a gon ring should have a length that is a multiple of 3'''				)

	if min(numbers[::3]				) != numbers[0]:
		return False

	lowerCAmelCase__			:		int						       =			sum(numbers[:3]				)

	return all(sum(numbers[i : i + 3]				) == total for i in range(3		,  len(A_				)		,  3				)				)


if __name__ == "__main__":
							print(solution())




