code: 
  
  
  
  
  
  '''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    )    )
  
  
style_context: 
  
  
  
  
  
  '''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() = }')
  
  