

"""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 ,						_A ,						_A=13 ,						_A=32 ,						_A=1 ,						_A=3 ,						_A=16 ,						_A=[1, 2, 1] ,						_A=[2, 2, 4] ,						_A=2 ,						_A=2.0 ,						_A=True ,						_A=0.0 ,						_A=0.0 ,						_A=0.1 ,						_A="gelu" ,						_A=False ,						_A=True ,						_A=0.02 ,						_A=1e-5 ,						_A=True ,						_A=None ,						_A=False ,						_A=2 ,						)      ->      Union[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							Union[str, Any]       =   parent
				_UpperCAmelCase      :							Optional[Any]       =   batch_size
				_UpperCAmelCase      :							str       =   image_size
				_UpperCAmelCase      :							List[str]       =   patch_size
				_UpperCAmelCase      :							Optional[int]       =   num_channels
				_UpperCAmelCase      :							Any       =   embed_dim
				_UpperCAmelCase      :							Dict       =   depths
				_UpperCAmelCase      :							str       =   num_heads
				_UpperCAmelCase      :							List[Any]       =   window_size
				_UpperCAmelCase      :							Dict       =   mlp_ratio
				_UpperCAmelCase      :							Any       =   qkv_bias
				_UpperCAmelCase      :							Tuple       =   hidden_dropout_prob
				_UpperCAmelCase      :							Union[str, Any]       =   attention_probs_dropout_prob
				_UpperCAmelCase      :							int       =   drop_path_rate
				_UpperCAmelCase      :							List[str]       =   hidden_act
				_UpperCAmelCase      :							Optional[Any]       =   use_absolute_embeddings
				_UpperCAmelCase      :							List[str]       =   patch_norm
				_UpperCAmelCase      :							List[str]       =   layer_norm_eps
				_UpperCAmelCase      :							List[str]       =   initializer_range
				_UpperCAmelCase      :							List[str]       =   is_training
				_UpperCAmelCase      :							Optional[Any]       =   scope
				_UpperCAmelCase      :							Dict       =   use_labels
				_UpperCAmelCase      :							List[str]       =   upscale

				# here we set some attributes to make tests pass
				_UpperCAmelCase      :							Optional[int]       =   len(_A       )
				_UpperCAmelCase      :							Optional[Any]       =   embed_dim
				_UpperCAmelCase      :							Optional[Any]       =   (image_size // patch_size) ** 2
			def 							__snake_case	(						self       )      ->      List[str]:






				'''simple docstring'''







				_UpperCAmelCase      :							Union[str, Any]       =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

				_UpperCAmelCase      :							Any       =   None
				if self.use_labels:
					_UpperCAmelCase      :							Tuple       =   ids_tensor([self.batch_size] ,						self.type_sequence_label_size       )

				_UpperCAmelCase      :							Any       =   self.get_config()

				return config, pixel_values, labels
			def 							__snake_case	(						self       )      ->      Dict:






				'''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 							__snake_case	(						self ,						_A ,						_A ,						_A       )      ->      Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							Union[str, Any]       =   SwinaSRModel(config=_A       )
				model.to(_A       )
				model.eval()
				_UpperCAmelCase      :							Any       =   model(_A       )

				self.parent.assertEqual(
				    result.last_hidden_state.shape ,						(self.batch_size, self.embed_dim, self.image_size, self.image_size)       )
			def 							__snake_case	(						self ,						_A ,						_A ,						_A       )      ->      Any:






				'''simple docstring'''







				_UpperCAmelCase      :							int       =   SwinaSRForImageSuperResolution(_A       )
				model.to(_A       )
				model.eval()
				_UpperCAmelCase      :							List[str]       =   model(_A       )

				_UpperCAmelCase      :							List[str]       =   self.image_size * self.upscale
				self.parent.assertEqual(
				    result.reconstruction.shape ,						(self.batch_size, self.num_channels, expected_image_size, expected_image_size)       )
			def 							__snake_case	(						self       )      ->      Any:






				'''simple docstring'''







				_UpperCAmelCase      :							Tuple       =   self.prepare_config_and_inputs()
				_UpperCAmelCase  ,				_UpperCAmelCase  ,				_UpperCAmelCase      :							List[str]       =   config_and_inputs
				_UpperCAmelCase      :							List[Any]       =   {"""pixel_values""": pixel_values}
				return config, inputs_dict






@require_torch
class       _UpperCAmelCase     (						__a      ,       __a      ,       unittest.TestCase):
			__a	:    Tuple			   =							(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
			__a	:    Union[str, Any]			   =							{"""feature-extraction""": SwinaSRModel} if is_torch_available() else {}

			__a	:    Optional[Any]			   =							False
			__a	:    Tuple			   =							False
			__a	:    str			   =							False
			__a	:    Optional[int]			   =							False
			__a	:    Tuple			   =							False
			def 							__snake_case	(						self       )      ->      Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							Optional[int]       =   SwinaSRModelTester(self       )
				_UpperCAmelCase      :							Any       =   ConfigTester(self ,						config_class=_A ,						embed_dim=37       )
			def 							__snake_case	(						self       )      ->      Optional[Any]:






				'''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 							__snake_case	(						self       )      ->      Any:






				'''simple docstring'''







				_UpperCAmelCase      :							List[Any]       =   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_A       )
			def 							__snake_case	(						self       )      ->      str:






				'''simple docstring'''







				_UpperCAmelCase      :							Optional[int]       =   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_super_resolution(*_A       )
			@unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""       )
			def 							__snake_case	(						self       )      ->      Optional[int]:






				'''simple docstring'''







				pass
			@unittest.skip(reason="""Swin2SR does not use inputs_embeds"""       )
			def 							__snake_case	(						self       )      ->      Union[str, Any]:






				'''simple docstring'''







				pass
			@unittest.skip(reason="""Swin2SR does not support training yet"""       )
			def 							__snake_case	(						self       )      ->      Optional[Any]:






				'''simple docstring'''







				pass
			@unittest.skip(reason="""Swin2SR does not support training yet"""       )
			def 							__snake_case	(						self       )      ->      int:






				'''simple docstring'''







				pass
			def 							__snake_case	(						self       )      ->      Optional[int]:






				'''simple docstring'''







				_UpperCAmelCase  ,				_UpperCAmelCase      :							Optional[int]       =   self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					_UpperCAmelCase      :							List[str]       =   model_class(_A       )
					self.assertIsInstance(model.get_input_embeddings() ,						(nn.Module)       )
					_UpperCAmelCase      :							List[str]       =   model.get_output_embeddings()
					self.assertTrue(x is None or isinstance(_A ,						nn.Linear       )       )
			def 							__snake_case	(						self       )      ->      str:






				'''simple docstring'''







				_UpperCAmelCase  ,				_UpperCAmelCase      :							Dict       =   self.model_tester.prepare_config_and_inputs_for_common()

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

					_UpperCAmelCase      :							int       =   ["""pixel_values"""]
					self.assertListEqual(arg_names[:1] ,						_A       )
			@slow
			def 							__snake_case	(						self       )      ->      int:






				'''simple docstring'''







				for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_UpperCAmelCase      :							Dict       =   SwinaSRModel.from_pretrained(_A       )
					self.assertIsNotNone(_A       )
			def 							__snake_case	(						self       )      ->      Any:






				'''simple docstring'''







				_UpperCAmelCase  ,				_UpperCAmelCase      :							int       =   self.model_tester.prepare_config_and_inputs_for_common()

				_UpperCAmelCase      :							List[str]       =   _config_zero_init(_A       )
				for model_class in self.all_model_classes:
					_UpperCAmelCase      :							List[str]       =   model_class(config=_A       )
					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 							__snake_case	(						self       )      ->      int:






				'''simple docstring'''







				_UpperCAmelCase  ,				_UpperCAmelCase      :							List[str]       =   self.model_tester.prepare_config_and_inputs_for_common()
				_UpperCAmelCase      :							List[Any]       =   True

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

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

					# Check attention is always last and order is fine
					_UpperCAmelCase      :							List[str]       =   True
					_UpperCAmelCase      :							str       =   True
					_UpperCAmelCase      :							Tuple       =   model_class(_A       )
					model.to(_A       )
					model.eval()
					with torch.no_grad():
						_UpperCAmelCase      :							int       =   model(**self._prepare_for_class(_A ,						_A       )       )

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

					_UpperCAmelCase      :							Any       =   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] ,						)






@require_vision
@require_torch
@slow
class       _UpperCAmelCase     (						unittest.TestCase):
			def 							__snake_case	(						self       )      ->      List[str]:






				'''simple docstring'''







				_UpperCAmelCase      :							Tuple       =   SwinaSRImageProcessor()
				_UpperCAmelCase      :							Tuple       =   SwinaSRForImageSuperResolution.from_pretrained("""caidas/swin2SR-classical-sr-x2-64"""       ).to(_A       )

				_UpperCAmelCase      :							int       =   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
				_UpperCAmelCase      :							Union[str, Any]       =   processor(images=_A ,						return_tensors="""pt"""       ).to(_A       )

				# forward pass
				with torch.no_grad():
					_UpperCAmelCase      :							List[str]       =   model(**_A       )

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








"""simple docstring"""






from math import factorial
def  UpperCamelCase   (     _lowerCAmelCase       :  Dict,					_lowerCAmelCase       :  List[str]	)			->     Dict:
	return factorial(_lowerCAmelCase	) / (factorial(_lowerCAmelCase	) * factorial(n - r	))
def  UpperCamelCase   (     )			->     Tuple:
	_UpperCAmelCase      :							Optional[int]       =   0

	for i in range(1,					101	):
		for j in range(1,					i + 1	):
			if combinations(_lowerCAmelCase,					_lowerCAmelCase	) > 1E6:
				total += 1
	return total


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





