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



							'''simple docstring'''







							def __init__(    self     ,						_lowerCamelCase     ,						_lowerCamelCase=13     ,						_lowerCamelCase=32     ,						_lowerCamelCase=2     ,						_lowerCamelCase=3     ,						_lowerCamelCase=16     ,						_lowerCamelCase=[1, 2, 1]     ,						_lowerCamelCase=[2, 2, 4]     ,						_lowerCamelCase=2     ,						_lowerCamelCase=2.0     ,						_lowerCamelCase=True     ,						_lowerCamelCase=0.0     ,						_lowerCamelCase=0.0     ,						_lowerCamelCase=0.1     ,						_lowerCamelCase="gelu"     ,						_lowerCamelCase=False     ,						_lowerCamelCase=True     ,						_lowerCamelCase=0.02     ,						_lowerCamelCase=1e-5     ,						_lowerCamelCase=True     ,						_lowerCamelCase=None     ,						_lowerCamelCase=True     ,						_lowerCamelCase=10     ,						_lowerCamelCase=8     ,						_lowerCamelCase=["stage1", "stage2"]     ,						_lowerCamelCase=[1, 2]     ,						) ->       str:




										'''simple docstring'''
										__lowercase						      =					parent
										__lowercase						      =					batch_size
										__lowercase						      =					image_size
										__lowercase						      =					patch_size
										__lowercase						      =					num_channels
										__lowercase						      =					embed_dim
										__lowercase						      =					depths
										__lowercase						      =					num_heads
										__lowercase						      =					window_size
										__lowercase						      =					mlp_ratio
										__lowercase						      =					qkv_bias
										__lowercase						      =					hidden_dropout_prob
										__lowercase						      =					attention_probs_dropout_prob
										__lowercase						      =					drop_path_rate
										__lowercase						      =					hidden_act
										__lowercase						      =					use_absolute_embeddings
										__lowercase						      =					patch_norm
										__lowercase						      =					layer_norm_eps
										__lowercase						      =					initializer_range
										__lowercase						      =					is_training
										__lowercase						      =					scope
										__lowercase						      =					use_labels
										__lowercase						      =					type_sequence_label_size
										__lowercase						      =					encoder_stride
										__lowercase						      =					out_features
										__lowercase						      =					out_indices
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[int]:




										'''simple docstring'''
										__lowercase						      =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

										__lowercase						      =					self.get_config()

										return config, pixel_values, labels
							def      SCREAMING_SNAKE_CASE	(    self					) ->       List[str]:




										'''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      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					) ->       Tuple:




										'''simple docstring'''
										__lowercase						      =					SwinModel(config=_lowerCamelCase					)
										model.to(_lowerCamelCase					)
										model.eval()
										__lowercase						      =					model(_lowerCamelCase					)

										__lowercase						      =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
										__lowercase						      =					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     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					) ->       Tuple:




										'''simple docstring'''
										__lowercase						      =					SwinBackbone(config=_lowerCamelCase					)
										model.to(_lowerCamelCase					)
										model.eval()
										__lowercase						      =					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
										__lowercase						      =					None
										__lowercase						      =					SwinBackbone(config=_lowerCamelCase					)
										model.to(_lowerCamelCase					)
										model.eval()
										__lowercase						      =					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      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					) ->       List[str]:




										'''simple docstring'''
										__lowercase						      =					SwinForMaskedImageModeling(config=_lowerCamelCase					)
										model.to(_lowerCamelCase					)
										model.eval()
										__lowercase						      =					model(_lowerCamelCase					)
										self.parent.assertEqual(
										    result.logits.shape     ,						(self.batch_size, self.num_channels, self.image_size, self.image_size)					)

										# test greyscale images
										__lowercase						      =					1
										__lowercase						      =					SwinForMaskedImageModeling(_lowerCamelCase					)
										model.to(_lowerCamelCase					)
										model.eval()

										__lowercase						      =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
										__lowercase						      =					model(_lowerCamelCase					)
										self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, 1, self.image_size, self.image_size)					)
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					) ->       Any:




										'''simple docstring'''
										__lowercase						      =					self.type_sequence_label_size
										__lowercase						      =					SwinForImageClassification(_lowerCamelCase					)
										model.to(_lowerCamelCase					)
										model.eval()
										__lowercase						      =					model(_lowerCamelCase     ,						labels=_lowerCamelCase					)
										self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.type_sequence_label_size)					)

										# test greyscale images
										__lowercase						      =					1
										__lowercase						      =					SwinForImageClassification(_lowerCamelCase					)
										model.to(_lowerCamelCase					)
										model.eval()

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





							def      SCREAMING_SNAKE_CASE	(    self					) ->       Any:




										'''simple docstring'''
										__lowercase						      =					self.prepare_config_and_inputs()
										(
										    (
										    __lowercase		
										)      ,				(
										    __lowercase		
										)      ,				(
										    __lowercase		
										)      ,						
										)						      =					config_and_inputs
										__lowercase						      =					{"pixel_values": pixel_values}
										return config, inputs_dict





@require_torch
class 				__a    (   UpperCAmelCase_				,      UpperCAmelCase_				,      unittest.TestCase					):



							'''simple docstring'''







							_lowerCamelCase				: List[str]					      =      (
							    (
							        SwinModel,
							        SwinBackbone,
							        SwinForImageClassification,
							        SwinForMaskedImageModeling,
							    )
							    if is_torch_available()
							    else ()
							)
							_lowerCamelCase				: int					      =      (
							    {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
							    if is_torch_available()
							    else {}
							)
							_lowerCamelCase				: Union[str, Any]					      =      True

							_lowerCamelCase				: str					      =      False
							_lowerCamelCase				: int					      =      False
							_lowerCamelCase				: Any					      =      False
							def      SCREAMING_SNAKE_CASE	(    self					) ->       List[str]:




										'''simple docstring'''
										__lowercase						      =					SwinModelTester(self					)
										__lowercase						      =					ConfigTester(self     ,						config_class=_lowerCamelCase     ,						embed_dim=37					)
							def      SCREAMING_SNAKE_CASE	(    self					) ->       List[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      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[Any]:




										'''simple docstring'''
										return
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[Any]:




										'''simple docstring'''
										__lowercase						      =					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      SCREAMING_SNAKE_CASE	(    self					) ->       str:




										'''simple docstring'''
										pass
							def      SCREAMING_SNAKE_CASE	(    self					) ->       List[Any]:




										'''simple docstring'''
										super().test_training_gradient_checkpointing()
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[int]:




										'''simple docstring'''
										__lowercase						      =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*_lowerCamelCase					)
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[int]:




										'''simple docstring'''
										__lowercase						      =					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*_lowerCamelCase					)
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[Any]:




										'''simple docstring'''
										__lowercase						      =					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      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[int]:




										'''simple docstring'''
										pass
							@unittest.skip(reason="Swin Transformer does not use feedforward chunking"					)
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Tuple:




										'''simple docstring'''
										pass
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[int]:




										'''simple docstring'''
										__lowercase      ,				__lowercase						      =					self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													__lowercase						      =					model_class(_lowerCamelCase					)
													self.assertIsInstance(model.get_input_embeddings()     ,						(nn.Module)					)
													__lowercase						      =					model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(_lowerCamelCase     ,						nn.Linear					)					)
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Tuple:




										'''simple docstring'''
										__lowercase      ,				__lowercase						      =					self.model_tester.prepare_config_and_inputs_for_common()

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

													__lowercase						      =					["pixel_values"]
													self.assertListEqual(arg_names[:1]     ,						_lowerCamelCase					)
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Tuple:




										'''simple docstring'''
										__lowercase      ,				__lowercase						      =					self.model_tester.prepare_config_and_inputs_for_common()
										__lowercase						      =					True

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

													# check that output_attentions also work using config
													del inputs_dict["output_attentions"]
													__lowercase						      =					True
													__lowercase						      =					config.window_size**2
													__lowercase						      =					model_class(_lowerCamelCase					)
													model.to(_lowerCamelCase					)
													model.eval()
													with torch.no_grad():
																__lowercase						      =					model(**self._prepare_for_class(_lowerCamelCase     ,						_lowerCamelCase					)					)
													__lowercase						      =					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]     ,						)
													__lowercase						      =					len(_lowerCamelCase					)

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

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

													__lowercase						      =					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      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					) ->       Union[str, Any]:




										'''simple docstring'''
										__lowercase						      =					model_class(_lowerCamelCase					)
										model.to(_lowerCamelCase					)
										model.eval()

										with torch.no_grad():
													__lowercase						      =					model(**self._prepare_for_class(_lowerCamelCase     ,						_lowerCamelCase					)					)

										__lowercase						      =					outputs.hidden_states

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

										__lowercase						      =					(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":
													__lowercase						      =					outputs.reshaped_hidden_states
													self.assertEqual(len(_lowerCamelCase					)     ,						_lowerCamelCase					)

													__lowercase      ,				__lowercase      ,				__lowercase      ,				__lowercase						      =					reshaped_hidden_states[0].shape
													__lowercase						      =					(
													    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      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[int]:




										'''simple docstring'''
										__lowercase      ,				__lowercase						      =					self.model_tester.prepare_config_and_inputs_for_common()

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

													self.check_hidden_states_output(_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase					)
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Union[str, Any]:




										'''simple docstring'''
										__lowercase      ,				__lowercase						      =					self.model_tester.prepare_config_and_inputs_for_common()
										__lowercase						      =					3

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

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

										for model_class in self.all_model_classes:
													__lowercase						      =					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"]
													__lowercase						      =					True
													self.check_hidden_states_output(_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						(padded_height, padded_width)					)
							@slow
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Optional[Any]:




										'''simple docstring'''
										for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__lowercase						      =					SwinModel.from_pretrained(_lowerCamelCase					)
													self.assertIsNotNone(_lowerCamelCase					)





							def      SCREAMING_SNAKE_CASE	(    self					) ->       Any:




										'''simple docstring'''
										__lowercase      ,				__lowercase						      =					self.model_tester.prepare_config_and_inputs_for_common()

										__lowercase						      =					_config_zero_init(_lowerCamelCase					)
										for model_class in self.all_model_classes:
													__lowercase						      =					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 				__a    (   unittest.TestCase					):



							'''simple docstring'''







							@cached_property
							def      SCREAMING_SNAKE_CASE	(    self					) ->       int:




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





							@slow
							def      SCREAMING_SNAKE_CASE	(    self					) ->       Dict:




										'''simple docstring'''
										__lowercase						      =					SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224"					).to(_lowerCamelCase					)
										__lowercase						      =					self.default_image_processor

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

										# forward pass
										with torch.no_grad():
													__lowercase						      =					model(**_lowerCamelCase					)

										# verify the logits
										__lowercase						      =					torch.Size((1, 1_000)					)
										self.assertEqual(outputs.logits.shape     ,						_lowerCamelCase					)
										__lowercase						      =					torch.tensor([-0.0948, -0.6454, -0.0921]					).to(_lowerCamelCase					)
										self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,						_lowerCamelCase     ,						atol=1e-4					)					)





@require_torch
class 				__a    (   unittest.TestCase				,      UpperCAmelCase_					):



							'''simple docstring'''







							_lowerCamelCase				: Optional[int]					      =      (SwinBackbone,) if is_torch_available() else ()
							_lowerCamelCase				: Any					      =      SwinConfig
							def      SCREAMING_SNAKE_CASE	(    self					) ->       str:




										'''simple docstring'''
										__lowercase						      =					SwinModelTester(self					)







"""simple docstring"""






import os



def     lowerCAmelCase__ (		)	->Tuple:
			__lowercase						      =					0
			__lowercase						      =					0
			with open(os.path.dirname(__magic_name__			) + "/p022_names.txt"			) as file:
						__lowercase						      =					str(file.readlines()[0]			)
						__lowercase						      =					name.replace("\"" ,      ""			).split(","			)

			name.sort()
			for i in range(len(__magic_name__			)			):
						for j in name[i]:
									temp_sum += ord(__magic_name__			) - ord("A"			) + 1
						total_sum += (i + 1) * temp_sum
						__lowercase						      =					0
			return total_sum


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





