

"""simple docstring"""




import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
	import torch
	from torch import nn

	from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
	from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor





class 			__UpperCamelCase :


		def __init__(self :		int     ,     __SCREAMING_SNAKE_CASE :		int     ,     __SCREAMING_SNAKE_CASE :		Any=1_3     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]=3_2     ,     __SCREAMING_SNAKE_CASE :		Any=2     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=3     ,     __SCREAMING_SNAKE_CASE :		Dict=1_6     ,     __SCREAMING_SNAKE_CASE :		Dict=[1, 2, 1]     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=[2, 2, 4]     ,     __SCREAMING_SNAKE_CASE :		str=2     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]=2.0     ,     __SCREAMING_SNAKE_CASE :		int=True     ,     __SCREAMING_SNAKE_CASE :		Any=0.0     ,     __SCREAMING_SNAKE_CASE :		Optional[int]=0.0     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]=0.1     ,     __SCREAMING_SNAKE_CASE :		Dict="gelu"     ,     __SCREAMING_SNAKE_CASE :		int=False     ,     __SCREAMING_SNAKE_CASE :		int=True     ,     __SCREAMING_SNAKE_CASE :		str=0.0_2     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]=1E-5     ,     __SCREAMING_SNAKE_CASE :		Tuple=True     ,     __SCREAMING_SNAKE_CASE :		Tuple=None     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]=True     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]=1_0     ,     __SCREAMING_SNAKE_CASE :		int=8     ,     __SCREAMING_SNAKE_CASE :		str=["stage1", "stage2"]     ,     __SCREAMING_SNAKE_CASE :		Union[str, Any]=[1, 2]     ,     ):
							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 					SCREAMING_SNAKE_CASE__   (self :		Optional[int]):
							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 					SCREAMING_SNAKE_CASE__   (self :		List[str]):
							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 :		List[str]     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		List[str]     ,     __SCREAMING_SNAKE_CASE :		Dict):
							A			=					SwinModel(config=A_)
							model.to(A_)
							model.eval()
							A			=					model(A_)

							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 					SCREAMING_SNAKE_CASE__   (self :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		List[str]):
							A			=					SwinBackbone(config=A_)
							model.to(A_)
							model.eval()
							A			=					model(A_)

							# 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
							A			=					None
							A			=					SwinBackbone(config=A_)
							model.to(A_)
							model.eval()
							A			=					model(A_)

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

							# test greyscale images
							A			=					1
							A			=					SwinForMaskedImageModeling(A_)
							model.to(A_)
							model.eval()

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


		def 					SCREAMING_SNAKE_CASE__   (self :		Tuple     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		Tuple):
							A			=					self.type_sequence_label_size
							A			=					SwinForImageClassification(A_)
							model.to(A_)
							model.eval()
							A			=					model(A_     ,     labels=A_)
							self.parent.assertEqual(result.logits.shape     ,     (self.batch_size, self.type_sequence_label_size))

							# test greyscale images
							A			=					1
							A			=					SwinForImageClassification(A_)
							model.to(A_)
							model.eval()

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


		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[Any]):
							A			=					self.prepare_config_and_inputs()
							(
							    A							
							)			=					config_and_inputs
							A			=					{"pixel_values": pixel_values}
							return config, inputs_dict





@require_torch
class 			__UpperCamelCase (   _A     ,		_A     ,		unittest.TestCase						):
		SCREAMING_SNAKE_CASE								=    (
		    (
		        SwinModel,
		        SwinBackbone,
		        SwinForImageClassification,
		        SwinForMaskedImageModeling,
		    )
		    if is_torch_available()
		    else ()
		)
		SCREAMING_SNAKE_CASE								=    (
		    {"feature-extraction": SwinModel, "image-classification": SwinForImageClassification}
		    if is_torch_available()
		    else {}
		)
		SCREAMING_SNAKE_CASE								=    True

		SCREAMING_SNAKE_CASE								=    False
		SCREAMING_SNAKE_CASE								=    False
		SCREAMING_SNAKE_CASE								=    False


		def 					SCREAMING_SNAKE_CASE__   (self :		List[Any]):
							A			=					SwinModelTester(self)
							A			=					ConfigTester(self     ,     config_class=A_     ,     embed_dim=3_7)


		def 					SCREAMING_SNAKE_CASE__   (self :		List[Any]):
							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 :		int):
							return


		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[Any]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*A_)


		@unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0.")
		def 					SCREAMING_SNAKE_CASE__   (self :		Union[str, Any]):
							pass


		def 					SCREAMING_SNAKE_CASE__   (self :		Tuple):
							super().test_training_gradient_checkpointing()


		def 					SCREAMING_SNAKE_CASE__   (self :		Union[str, Any]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*A_)


		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[Any]):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*A_)


		def 					SCREAMING_SNAKE_CASE__   (self :		int):
							A			=					self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*A_)


		@unittest.skip(reason="Swin does not use inputs_embeds")
		def 					SCREAMING_SNAKE_CASE__   (self :		Union[str, Any]):
							pass


		@unittest.skip(reason="Swin Transformer does not use feedforward chunking")
		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[int]):
							pass


		def 					SCREAMING_SNAKE_CASE__   (self :		Tuple):
							A			=					self.model_tester.prepare_config_and_inputs_for_common()

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


		def 					SCREAMING_SNAKE_CASE__   (self :		str):
							A			=					self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												A			=					model_class(A_)
												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]     ,     A_)


		def 					SCREAMING_SNAKE_CASE__   (self :		Dict):
							A			=					self.model_tester.prepare_config_and_inputs_for_common()
							A			=					True

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

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

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

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

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

												A			=					outputs.attentions

												self.assertEqual(len(A_)     ,     A_)

												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 :		Optional[int]     ,     __SCREAMING_SNAKE_CASE :		str     ,     __SCREAMING_SNAKE_CASE :		List[Any]     ,     __SCREAMING_SNAKE_CASE :		Optional[Any]     ,     __SCREAMING_SNAKE_CASE :		Optional[int]):
							A			=					model_class(A_)
							model.to(A_)
							model.eval()

							with torch.no_grad():
												A			=					model(**self._prepare_for_class(A_     ,     A_))

							A			=					outputs.hidden_states

							A			=					getattr(
							    self.model_tester     ,     "expected_num_hidden_layers"     ,     len(self.model_tester.depths) + 1)
							self.assertEqual(len(A_)     ,     A_)

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

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

												A			=					reshaped_hidden_states[0].shape
												A			=					(
												    reshaped_hidden_states[0].view(A_     ,     A_     ,     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]):
							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(A_     ,     A_     ,     A_     ,     A_)

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												A			=					True

												self.check_hidden_states_output(A_     ,     A_     ,     A_     ,     A_)


		def 					SCREAMING_SNAKE_CASE__   (self :		str):
							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(A_     ,     A_     ,     A_     ,     (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(A_     ,     A_     ,     A_     ,     (padded_height, padded_width))


		@slow
		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[Any]):


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


		def 					SCREAMING_SNAKE_CASE__   (self :		Union[str, Any]):
							A			=					self.model_tester.prepare_config_and_inputs_for_common()

							A			=					_config_zero_init(A_)
							for model_class in self.all_model_classes:
												A			=					model_class(config=A_)
												for name, param in model.named_parameters():
																	if "embeddings" not in name and param.requires_grad:
																						self.assertIn(
																						    ((param.data.mean() * 1E9).round() / 1E9).item()     ,     [0.0, 1.0]     ,     msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""     ,     )





@require_vision
@require_torch
class 			__UpperCamelCase (   unittest.TestCase						):


		@cached_property
		def 					SCREAMING_SNAKE_CASE__   (self :		List[str]):
							return (
							    AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224")
							    if is_vision_available()
							    else None
							)


		@slow
		def 					SCREAMING_SNAKE_CASE__   (self :		Optional[int]):
							A			=					SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224").to(A_)
							A			=					self.default_image_processor

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

							# forward pass
							with torch.no_grad():
												A			=					model(**A_)

							# verify the logits
							A			=					torch.Size((1, 1_0_0_0))
							self.assertEqual(outputs.logits.shape     ,     A_)
							A			=					torch.tensor([-0.0_9_4_8, -0.6_4_5_4, -0.0_9_2_1]).to(A_)
							self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,     A_     ,     atol=1E-4))





@require_torch
class 			__UpperCamelCase (   unittest.TestCase     ,		_A						):
		SCREAMING_SNAKE_CASE								=    (SwinBackbone,) if is_torch_available() else ()
		SCREAMING_SNAKE_CASE								=    SwinConfig


		def 					SCREAMING_SNAKE_CASE__   (self :		str):
							A			=					SwinModelTester(self)








import math

def 							__SCREAMING_SNAKE_CASE							( lowerCAmelCase:     int       )      ->				list:
				if n <= 0:
								raise ValueError("Only positive integers have prime factors"       )
				_UpperCAmelCase				:						Union[str, Any]       						=			[]
				while n % 2 == 0:
								pf.append(2       )
								_UpperCAmelCase				:						Tuple       						=			int(n / 2       )
				for i in range(3     ,					int(math.sqrt(lowerCAmelCase       )       ) + 1     ,					2       ):
								while n % i == 0:
												pf.append(lowerCAmelCase       )
												_UpperCAmelCase				:						Optional[int]       						=			int(n / i       )
				if n > 2:
								pf.append(lowerCAmelCase       )
				return pf

def 							__SCREAMING_SNAKE_CASE							( lowerCAmelCase:     int       )      ->				int:
				if n <= 0:
								raise ValueError("Only positive numbers are accepted"       )
				_UpperCAmelCase				:						Dict       						=			1
				_UpperCAmelCase				:						str       						=			1
				while n % 2 == 0:
								temp += 1
								_UpperCAmelCase				:						List[str]       						=			int(n / 2       )
				div *= temp
				for i in range(3     ,					int(math.sqrt(lowerCAmelCase       )       ) + 1     ,					2       ):
								_UpperCAmelCase				:						Any       						=			1
								while n % i == 0:
												temp += 1
												_UpperCAmelCase				:						Any       						=			int(n / i       )
								div *= temp
				if n > 1:
								div *= 2
				return div

def 							__SCREAMING_SNAKE_CASE							( lowerCAmelCase:     int       )      ->				int:
				if n <= 0:
								raise ValueError("Only positive numbers are accepted"       )
				_UpperCAmelCase				:						Optional[Any]       						=			1
				_UpperCAmelCase				:						Union[str, Any]       						=			1
				while n % 2 == 0:
								temp += 1
								_UpperCAmelCase				:						Optional[Any]       						=			int(n / 2       )
				if temp > 1:
								s *= (2**temp - 1) / (2 - 1)
				for i in range(3     ,					int(math.sqrt(lowerCAmelCase       )       ) + 1     ,					2       ):
								_UpperCAmelCase				:						List[str]       						=			1
								while n % i == 0:
												temp += 1
												_UpperCAmelCase				:						List[Any]       						=			int(n / i       )
								if temp > 1:
												s *= (i**temp - 1) / (i - 1)
				return int(lowerCAmelCase       )

def 							__SCREAMING_SNAKE_CASE							( lowerCAmelCase:     int       )      ->				int:
				_UpperCAmelCase				:						Any       						=			n
				for x in set(prime_factors(lowerCAmelCase       )       ):
								s *= (x - 1) / x
				return int(lowerCAmelCase       )


if __name__ == "__main__":
					import doctest

					doctest.testmod()


