





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					,    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:
										_snake_case						=					parent
										_snake_case						=					batch_size
										_snake_case						=					image_size
										_snake_case						=					patch_size
										_snake_case						=					num_channels
										_snake_case						=					embed_dim
										_snake_case						=					depths
										_snake_case						=					num_heads
										_snake_case						=					window_size
										_snake_case						=					mlp_ratio
										_snake_case						=					qkv_bias
										_snake_case						=					hidden_dropout_prob
										_snake_case						=					attention_probs_dropout_prob
										_snake_case						=					drop_path_rate
										_snake_case						=					hidden_act
										_snake_case						=					use_absolute_embeddings
										_snake_case						=					patch_norm
										_snake_case						=					layer_norm_eps
										_snake_case						=					initializer_range
										_snake_case						=					is_training
										_snake_case						=					scope
										_snake_case						=					use_labels
										_snake_case						=					type_sequence_label_size
										_snake_case						=					encoder_stride
										_snake_case						=					out_features
										_snake_case						=					out_indices




					def 						lowerCAmelCase      (		self	)		->				Optional[int]:
										_snake_case						=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

										_snake_case						=					self.get_config()

										return config, pixel_values, labels




					def 						lowerCAmelCase      (		self	)		->				Tuple:
										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					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)		->				str:
										_snake_case						=					SwinModel(config=lowerCAmelCase_	)
										model.to(lowerCAmelCase_	)
										model.eval()
										_snake_case						=					model(lowerCAmelCase_	)

										_snake_case						=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
										_snake_case						=					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					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)		->				Any:
										_snake_case						=					SwinBackbone(config=lowerCAmelCase_	)
										model.to(lowerCAmelCase_	)
										model.eval()
										_snake_case						=					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
										_snake_case						=					None
										_snake_case						=					SwinBackbone(config=lowerCAmelCase_	)
										model.to(lowerCAmelCase_	)
										model.eval()
										_snake_case						=					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 						lowerCAmelCase      (		self					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)		->				Dict:
										_snake_case						=					SwinForMaskedImageModeling(config=lowerCAmelCase_	)
										model.to(lowerCAmelCase_	)
										model.eval()
										_snake_case						=					model(lowerCAmelCase_	)
										self.parent.assertEqual(
										    result.logits.shape					,    (self.batch_size, self.num_channels, self.image_size, self.image_size)	)

										# test greyscale images
										_snake_case						=					1
										_snake_case						=					SwinForMaskedImageModeling(lowerCAmelCase_	)
										model.to(lowerCAmelCase_	)
										model.eval()

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




					def 						lowerCAmelCase      (		self					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)		->				List[Any]:
										_snake_case						=					self.type_sequence_label_size
										_snake_case						=					SwinForImageClassification(lowerCAmelCase_	)
										model.to(lowerCAmelCase_	)
										model.eval()
										_snake_case						=					model(lowerCAmelCase_					,    labels=lowerCAmelCase_	)
										self.parent.assertEqual(result.logits.shape					,    (self.batch_size, self.type_sequence_label_size)	)

										# test greyscale images
										_snake_case						=					1
										_snake_case						=					SwinForImageClassification(lowerCAmelCase_	)
										model.to(lowerCAmelCase_	)
										model.eval()

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






					def 						lowerCAmelCase      (		self	)		->				int:
										_snake_case						=					self.prepare_config_and_inputs()
										(
										    (
										    _snake_case
										)				,  (
										    _snake_case
										)				,  (
										    _snake_case
										)				,  
										)						=					config_and_inputs
										_snake_case						=					{'pixel_values': pixel_values}
										return config, inputs_dict





@require_torch
class       UpperCamelCase_		(	_lowerCamelCase				,	_lowerCamelCase				,	unittest.TestCase       ):
					lowerCAmelCase_				=						(
					    (
					        SwinModel,
					        SwinBackbone,
					        SwinForImageClassification,
					        SwinForMaskedImageModeling,
					    )
					    if is_torch_available()
					    else ()
					)
					lowerCAmelCase_				=						(
					    {'''feature-extraction''': SwinModel, '''image-classification''': SwinForImageClassification}
					    if is_torch_available()
					    else {}
					)
					lowerCAmelCase_				=						True

					lowerCAmelCase_				=						False
					lowerCAmelCase_				=						False
					lowerCAmelCase_				=						False




					def 						lowerCAmelCase      (		self	)		->				List[str]:
										_snake_case						=					SwinModelTester(self	)
										_snake_case						=					ConfigTester(self					,    config_class=lowerCAmelCase_					,    embed_dim=37	)




					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	)		->				List[Any]:
										return




					def 						lowerCAmelCase      (		self	)		->				str:
										_snake_case						=					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 						lowerCAmelCase      (		self	)		->				List[Any]:
										pass




					def 						lowerCAmelCase      (		self	)		->				Optional[Any]:
										super().test_training_gradient_checkpointing()




					def 						lowerCAmelCase      (		self	)		->				int:
										_snake_case						=					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Optional[Any]:
										_snake_case						=					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Union[str, Any]:
										_snake_case						=					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 						lowerCAmelCase      (		self	)		->				List[Any]:
										pass




					@unittest.skip(reason='Swin Transformer does not use feedforward chunking'	)
					def 						lowerCAmelCase      (		self	)		->				Optional[int]:
										pass




					def 						lowerCAmelCase      (		self	)		->				Optional[int]:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()

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




					def 						lowerCAmelCase      (		self	)		->				Tuple:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()

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

															_snake_case						=					['pixel_values']
															self.assertListEqual(arg_names[:1]					,    lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Dict:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()
										_snake_case						=					True

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

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

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

															# also another +1 for reshaped_hidden_states
															_snake_case						=					1 if model_class.__name__ == 'SwinBackbone' else 2
															self.assertEqual(out_len + added_hidden_states					,    len(lowerCAmelCase_	)	)

															_snake_case						=					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 						lowerCAmelCase      (		self					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)		->				Any:
										_snake_case						=					model_class(lowerCAmelCase_	)
										model.to(lowerCAmelCase_	)
										model.eval()

										with torch.no_grad():
															_snake_case						=					model(**self._prepare_for_class(lowerCAmelCase_					,    lowerCAmelCase_	)	)

										_snake_case						=					outputs.hidden_states

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

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

															_snake_case				,  _snake_case				,  _snake_case				,  _snake_case						=					reshaped_hidden_states[0].shape
															_snake_case						=					(
															    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 						lowerCAmelCase      (		self	)		->				Optional[int]:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()

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

															self.check_hidden_states_output(lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Optional[Any]:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()
										_snake_case						=					3

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

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

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




					@slow
					def 						lowerCAmelCase      (		self	)		->				Optional[Any]:
										for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_snake_case						=					SwinModel.from_pretrained(lowerCAmelCase_	)
															self.assertIsNotNone(lowerCAmelCase_	)






					def 						lowerCAmelCase      (		self	)		->				Optional[Any]:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()

										_snake_case						=					_config_zero_init(lowerCAmelCase_	)
										for model_class in self.all_model_classes:
															_snake_case						=					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       UpperCamelCase_		(	unittest.TestCase       ):




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






					@slow
					def 						lowerCAmelCase      (		self	)		->				int:
										_snake_case						=					SwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'	).to(lowerCAmelCase_	)
										_snake_case						=					self.default_image_processor

										_snake_case						=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
										_snake_case						=					image_processor(images=lowerCAmelCase_					,    return_tensors='pt'	).to(lowerCAmelCase_	)

										# forward pass
										with torch.no_grad():
															_snake_case						=					model(**lowerCAmelCase_	)

										# verify the logits
										_snake_case						=					torch.Size((1, 1000)	)
										self.assertEqual(outputs.logits.shape					,    lowerCAmelCase_	)
										_snake_case						=					torch.tensor([-0.09_48, -0.64_54, -0.09_21]	).to(lowerCAmelCase_	)
										self.assertTrue(torch.allclose(outputs.logits[0, :3]					,    lowerCAmelCase_					,    atol=1E-4	)	)





@require_torch
class       UpperCamelCase_		(	unittest.TestCase				,	_lowerCamelCase       ):
					lowerCAmelCase_				=						(SwinBackbone,) if is_torch_available() else ()
					lowerCAmelCase_				=						SwinConfig




					def 						lowerCAmelCase      (		self	)		->				Dict:
										_snake_case						=					SwinModelTester(self	)










import math
from timeit import timeit





def     lowerCamelCase__  (  UpperCamelCase__      :							int    )      ->			int:



					'''simple docstring'''




					_snake_case						=					0
					_snake_case						=					abs(UpperCamelCase__    )
					while True:
										_snake_case						=					n // 10
										digits += 1
										if n == 0:
															break
					return digits





def     lowerCamelCase__  (  UpperCamelCase__      :							int    )      ->			int:



					'''simple docstring'''




					return 1 if n == 0 else math.floor(math.log(abs(UpperCamelCase__    )							,     10    ) + 1    )





def     lowerCamelCase__  (  UpperCamelCase__      :							int    )      ->			int:



					'''simple docstring'''




					return len(str(abs(UpperCamelCase__    )    )    )





def     lowerCamelCase__  (  )      ->			None:



					'''simple docstring'''




					from collections.abc import Callable

					def benchmark_a_function(UpperCamelCase__      :							Callable							,     UpperCamelCase__      :							int    ) -> None:
										_snake_case						=					F'''{func.__name__}({value})'''
										_snake_case						=					timeit(F'''__main__.{call}'''							,     setup='import __main__'    )
										print(F'''{call}: {func(UpperCamelCase__    )} -- {timing} seconds'''    )

					for value in (262_144, 1_125_899_906_842_624, 1_267_650_600_228_229_401_496_703_205_376):
										for func in (num_digits, num_digits_fast, num_digits_faster):
															benchmark_a_function(UpperCamelCase__							,     UpperCamelCase__    )
										print()


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					benchmark()



