





'''simple docstring'''







import inspect
import unittest

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

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 SwinaSRForImageSuperResolution, SwinaSRModel
	from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
	from PIL import Image

	from transformers import SwinaSRImageProcessor





class 					_UpperCAmelCase							:
		def __init__(						self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE=13,__SCREAMING_SNAKE_CASE=32,__SCREAMING_SNAKE_CASE=1,__SCREAMING_SNAKE_CASE=3,__SCREAMING_SNAKE_CASE=16,__SCREAMING_SNAKE_CASE=[1, 2, 1],__SCREAMING_SNAKE_CASE=[2, 2, 4],__SCREAMING_SNAKE_CASE=2,__SCREAMING_SNAKE_CASE=2.0,__SCREAMING_SNAKE_CASE=True,__SCREAMING_SNAKE_CASE=0.0,__SCREAMING_SNAKE_CASE=0.0,__SCREAMING_SNAKE_CASE=0.1,__SCREAMING_SNAKE_CASE="gelu",__SCREAMING_SNAKE_CASE=False,__SCREAMING_SNAKE_CASE=True,__SCREAMING_SNAKE_CASE=0.02,__SCREAMING_SNAKE_CASE=1e-5,__SCREAMING_SNAKE_CASE=True,__SCREAMING_SNAKE_CASE=None,__SCREAMING_SNAKE_CASE=False,__SCREAMING_SNAKE_CASE=2,):



					'''simple docstring'''

					__lowerCAmelCase      		=       parent
					__lowerCAmelCase      		=       batch_size
					__lowerCAmelCase      		=       image_size
					__lowerCAmelCase      		=       patch_size
					__lowerCAmelCase      		=       num_channels
					__lowerCAmelCase      		=       embed_dim
					__lowerCAmelCase      		=       depths
					__lowerCAmelCase      		=       num_heads
					__lowerCAmelCase      		=       window_size
					__lowerCAmelCase      		=       mlp_ratio
					__lowerCAmelCase      		=       qkv_bias
					__lowerCAmelCase      		=       hidden_dropout_prob
					__lowerCAmelCase      		=       attention_probs_dropout_prob
					__lowerCAmelCase      		=       drop_path_rate
					__lowerCAmelCase      		=       hidden_act
					__lowerCAmelCase      		=       use_absolute_embeddings
					__lowerCAmelCase      		=       patch_norm
					__lowerCAmelCase      		=       layer_norm_eps
					__lowerCAmelCase      		=       initializer_range
					__lowerCAmelCase      		=       is_training
					__lowerCAmelCase      		=       scope
					__lowerCAmelCase      		=       use_labels
					__lowerCAmelCase      		=       upscale

					# here we set some attributes to make tests pass
					__lowerCAmelCase      		=       len(__SCREAMING_SNAKE_CASE    )
					__lowerCAmelCase      		=       embed_dim
					__lowerCAmelCase      		=       (image_size // patch_size) ** 2
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

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

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

					__lowerCAmelCase      		=       self.get_config()

					return config, pixel_values, labels
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					return SwinaSRConfig(
					    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,upscale=self.upscale,)
		def 						lowerCamelCase__    (						self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    ):



					'''simple docstring'''

					__lowerCAmelCase      		=       SwinaSRModel(config=__SCREAMING_SNAKE_CASE    )
					model.to(__SCREAMING_SNAKE_CASE    )
					model.eval()
					__lowerCAmelCase      		=       model(__SCREAMING_SNAKE_CASE    )

					self.parent.assertEqual(
					    result.last_hidden_state.shape,(self.batch_size, self.embed_dim, self.image_size, self.image_size)    )
		def 						lowerCamelCase__    (						self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    ):



					'''simple docstring'''

					__lowerCAmelCase      		=       SwinaSRForImageSuperResolution(__SCREAMING_SNAKE_CASE    )
					model.to(__SCREAMING_SNAKE_CASE    )
					model.eval()
					__lowerCAmelCase      		=       model(__SCREAMING_SNAKE_CASE    )

					__lowerCAmelCase      		=       self.image_size * self.upscale
					self.parent.assertEqual(
					    result.reconstruction.shape,(self.batch_size, self.num_channels, expected_image_size, expected_image_size)    )







		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

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





@require_torch
class 					_UpperCAmelCase							(		lowerCAmelCase_			,      lowerCAmelCase_			,      unittest.TestCase     ):
		a     :     List[Any]     						=(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
		a     :     Optional[Any]     						={"""feature-extraction""": SwinaSRModel} if is_torch_available() else {}

		a     :     str     						=False
		a     :     Dict     						=False
		a     :     Any     						=False
		a     :     Tuple     						=False
		a     :     Optional[int]     						=False
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					__lowerCAmelCase      		=       SwinaSRModelTester(self    )
					__lowerCAmelCase      		=       ConfigTester(self,config_class=__SCREAMING_SNAKE_CASE,embed_dim=37    )
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					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    ):



					'''simple docstring'''

					__lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE    )
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					__lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_super_resolution(*__SCREAMING_SNAKE_CASE    )
		@unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""    )
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					pass
		@unittest.skip(reason="""Swin2SR does not use inputs_embeds"""    )
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					pass
		@unittest.skip(reason="""Swin2SR does not support training yet"""    )
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					pass
		@unittest.skip(reason="""Swin2SR does not support training yet"""    )
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					pass
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					__lowerCAmelCase		, __lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs_for_common()

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



					'''simple docstring'''

					__lowerCAmelCase		, __lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs_for_common()

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

								__lowerCAmelCase      		=       ["""pixel_values"""]
								self.assertListEqual(arg_names[:1],__SCREAMING_SNAKE_CASE    )
		@slow
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								__lowerCAmelCase      		=       SwinaSRModel.from_pretrained(__SCREAMING_SNAKE_CASE    )
								self.assertIsNotNone(__SCREAMING_SNAKE_CASE    )
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					__lowerCAmelCase		, __lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs_for_common()

					__lowerCAmelCase      		=       _config_zero_init(__SCREAMING_SNAKE_CASE    )
					for model_class in self.all_model_classes:
								__lowerCAmelCase      		=       model_class(config=__SCREAMING_SNAKE_CASE    )
								for name, param in model.named_parameters():
											if "logit_scale" in name:
														continue
											if 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',)







		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					__lowerCAmelCase		, __lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs_for_common()
					__lowerCAmelCase      		=       True

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

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

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

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

								self.assertEqual(out_len + 1,len(__SCREAMING_SNAKE_CASE    )    )

								__lowerCAmelCase      		=       outputs.attentions

								self.assertEqual(len(__SCREAMING_SNAKE_CASE    ),__SCREAMING_SNAKE_CASE    )

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





@require_vision
@require_torch
@slow
class 					_UpperCAmelCase							(		unittest.TestCase     ):
		def 						lowerCamelCase__    (						self    ):



					'''simple docstring'''

					__lowerCAmelCase      		=       SwinaSRImageProcessor()
					__lowerCAmelCase      		=       SwinaSRForImageSuperResolution.from_pretrained("""caidas/swin2SR-classical-sr-x2-64"""    ).to(__SCREAMING_SNAKE_CASE    )

					__lowerCAmelCase      		=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
					__lowerCAmelCase      		=       processor(images=__SCREAMING_SNAKE_CASE,return_tensors="""pt"""    ).to(__SCREAMING_SNAKE_CASE    )

					# forward pass
					with torch.no_grad():
								__lowerCAmelCase      		=       model(**__SCREAMING_SNAKE_CASE    )

					# verify the logits
					__lowerCAmelCase      		=       torch.Size([1, 3, 9_76, 12_96]    )
					self.assertEqual(outputs.reconstruction.shape,__SCREAMING_SNAKE_CASE    )
					__lowerCAmelCase      		=       torch.tensor(
					    [[0.5458, 0.5546, 0.5638], [0.5526, 0.5565, 0.5651], [0.5396, 0.5426, 0.5621]]    ).to(__SCREAMING_SNAKE_CASE    )
					self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3],__SCREAMING_SNAKE_CASE,atol=1e-4    )    )








'''simple docstring'''







def      _lowerCAmelCase		(		lowercase = 1000			)      ->      int:
			__lowerCAmelCase      		=       []
			__lowerCAmelCase      		=       []
			__lowerCAmelCase      		=       3
			__lowerCAmelCase      		=       5
			__lowerCAmelCase      		=       1
			while True:
						__lowerCAmelCase      		=       z * temp
						if result < n:
									zmulti.append(lowercase			)
									temp += 1
						else:
									__lowerCAmelCase      		=       1
									break
			while True:
						__lowerCAmelCase      		=       x * temp
						if result < n:
									xmulti.append(lowercase			)
									temp += 1
						else:
									break
			__lowerCAmelCase      		=       list(set(xmulti + zmulti			)			)
			return sum(lowercase			)


if __name__ == "__main__":
	print(f'{solution() = }')

