code: 
  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_			:
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						def __init__( self       :Optional[int]		,						lowerCAmelCase__       :Optional[Any]		,						lowerCAmelCase__       :int=13		,						lowerCAmelCase__       :Any=32		,						lowerCAmelCase__       :str=1		,						lowerCAmelCase__       :Any=3		,						lowerCAmelCase__       :Optional[int]=16		,						lowerCAmelCase__       :Optional[int]=[1, 2, 1]		,						lowerCAmelCase__       :Union[str, Any]=[2, 2, 4]		,						lowerCAmelCase__       :Dict=2		,						lowerCAmelCase__       :str=2.0		,						lowerCAmelCase__       :Optional[Any]=True		,						lowerCAmelCase__       :str=0.0		,						lowerCAmelCase__       :List[str]=0.0		,						lowerCAmelCase__       :str=0.1		,						lowerCAmelCase__       :List[str]="gelu"		,						lowerCAmelCase__       :Optional[int]=False		,						lowerCAmelCase__       :int=True		,						lowerCAmelCase__       :Optional[Any]=0.02		,						lowerCAmelCase__       :Dict=1E-5		,						lowerCAmelCase__       :List[Any]=True		,						lowerCAmelCase__       :Dict=None		,						lowerCAmelCase__       :Optional[Any]=False		,						lowerCAmelCase__       :str=2		,						)     ->str:
  										lowercase						    =			parent
  										lowercase						    =			batch_size
  										lowercase						    =			image_size
  										lowercase						    =			patch_size
  										lowercase						    =			num_channels
  										lowercase						    =			embed_dim
  										lowercase						    =			depths
  										lowercase						    =			num_heads
  										lowercase						    =			window_size
  										lowercase						    =			mlp_ratio
  										lowercase						    =			qkv_bias
  										lowercase						    =			hidden_dropout_prob
  										lowercase						    =			attention_probs_dropout_prob
  										lowercase						    =			drop_path_rate
  										lowercase						    =			hidden_act
  										lowercase						    =			use_absolute_embeddings
  										lowercase						    =			patch_norm
  										lowercase						    =			layer_norm_eps
  										lowercase						    =			initializer_range
  										lowercase						    =			is_training
  										lowercase						    =			scope
  										lowercase						    =			use_labels
  										lowercase						    =			upscale
  
  										# here we set some attributes to make tests pass
  										lowercase						    =			len(lowerCAmelCase__    )
  										lowercase						    =			embed_dim
  										lowercase						    =			(image_size // patch_size) ** 2
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Optional[int]    )     ->List[Any]:
  										lowercase						    =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )
  
  										lowercase						    =			None
  										if self.use_labels:
  														lowercase						    =			ids_tensor([self.batch_size]		,						self.type_sequence_label_size    )
  
  										lowercase						    =			self.get_config()
  
  										return config, pixel_values, labels
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Tuple    )     ->Union[str, Any]:
  										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 					SCREAMING_SNAKE_CASE( self       :List[Any]		,						lowerCAmelCase__       :str		,						lowerCAmelCase__       :Optional[int]		,						lowerCAmelCase__       :int    )     ->Tuple:
  										lowercase						    =			SwinaSRModel(config=lowerCAmelCase__    )
  										model.to(lowerCAmelCase__    )
  										model.eval()
  										lowercase						    =			model(lowerCAmelCase__    )
  
  										self.parent.assertEqual(
  										    result.last_hidden_state.shape		,						(self.batch_size, self.embed_dim, self.image_size, self.image_size)    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :List[str]		,						lowerCAmelCase__       :List[Any]		,						lowerCAmelCase__       :str		,						lowerCAmelCase__       :Dict    )     ->str:
  										lowercase						    =			SwinaSRForImageSuperResolution(lowerCAmelCase__    )
  										model.to(lowerCAmelCase__    )
  										model.eval()
  										lowercase						    =			model(lowerCAmelCase__    )
  
  										lowercase						    =			self.image_size * self.upscale
  										self.parent.assertEqual(
  										    result.reconstruction.shape		,						(self.batch_size, self.num_channels, expected_image_size, expected_image_size)    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Any    )     ->Optional[int]:
  										lowercase						    =			self.prepare_config_and_inputs()
  										lowercase    ,  lowercase    ,  lowercase						    =			config_and_inputs
  										lowercase						    =			{"pixel_values": pixel_values}
  										return config, inputs_dict
  
  
  
  
  
  @require_torch
  class      UpperCamelCase_			(			__a		,						__a		,						unittest.TestCase		):
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCamelCase			:     Optional[Any]							      =				(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
  						UpperCamelCase			:     Any							      =				{'''feature-extraction''': SwinaSRModel} if is_torch_available() else {}
  
  						UpperCamelCase			:     Tuple							      =				False
  						UpperCamelCase			:     Union[str, Any]							      =				False
  						UpperCamelCase			:     Tuple							      =				False
  						UpperCamelCase			:     Dict							      =				False
  						UpperCamelCase			:     List[Any]							      =				False
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Optional[Any]    )     ->List[Any]:
  										lowercase						    =			SwinaSRModelTester(self    )
  										lowercase						    =			ConfigTester(self		,						config_class=lowerCAmelCase__		,						embed_dim=37    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :List[Any]    )     ->Any:
  										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       :Optional[Any]    )     ->Tuple:
  										lowercase						    =			self.model_tester.prepare_config_and_inputs()
  										self.model_tester.create_and_check_model(*lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :int    )     ->Optional[Any]:
  										lowercase						    =			self.model_tester.prepare_config_and_inputs()
  										self.model_tester.create_and_check_for_image_super_resolution(*lowerCAmelCase__    )
  
  
  
  
  
  						@unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0."    )
  						def 					SCREAMING_SNAKE_CASE( self       :Optional[int]    )     ->Any:
  										pass
  
  
  
  
  
  						@unittest.skip(reason="Swin2SR does not use inputs_embeds"    )
  						def 					SCREAMING_SNAKE_CASE( self       :List[str]    )     ->Optional[int]:
  										pass
  
  
  
  
  
  						@unittest.skip(reason="Swin2SR does not support training yet"    )
  						def 					SCREAMING_SNAKE_CASE( self       :List[str]    )     ->Optional[int]:
  										pass
  
  
  
  
  
  						@unittest.skip(reason="Swin2SR does not support training yet"    )
  						def 					SCREAMING_SNAKE_CASE( self       :Optional[Any]    )     ->Any:
  										pass
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Union[str, Any]    )     ->str:
  										lowercase    ,  lowercase						    =			self.model_tester.prepare_config_and_inputs_for_common()
  
  										for model_class in self.all_model_classes:
  														lowercase						    =			model_class(lowerCAmelCase__    )
  														self.assertIsInstance(model.get_input_embeddings()		,						(nn.Module)    )
  														lowercase						    =			model.get_output_embeddings()
  														self.assertTrue(x is None or isinstance(lowerCAmelCase__		,						nn.Linear    )    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :List[Any]    )     ->Union[str, Any]:
  										lowercase    ,  lowercase						    =			self.model_tester.prepare_config_and_inputs_for_common()
  
  										for model_class in self.all_model_classes:
  														lowercase						    =			model_class(lowerCAmelCase__    )
  														lowercase						    =			inspect.signature(model.forward    )
  														# signature.parameters is an OrderedDict => so arg_names order is deterministic
  														lowercase						    =			[*signature.parameters.keys()]
  
  														lowercase						    =			["pixel_values"]
  														self.assertListEqual(arg_names[:1]		,						lowerCAmelCase__    )
  
  
  
  
  
  						@slow
  						def 					SCREAMING_SNAKE_CASE( self       :List[Any]    )     ->Optional[Any]:
  										for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  														lowercase						    =			SwinaSRModel.from_pretrained(lowerCAmelCase__    )
  														self.assertIsNotNone(lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Dict    )     ->List[str]:
  										lowercase    ,  lowercase						    =			self.model_tester.prepare_config_and_inputs_for_common()
  
  										lowercase						    =			_config_zero_init(lowerCAmelCase__    )
  										for model_class in self.all_model_classes:
  														lowercase						    =			model_class(config=lowerCAmelCase__    )
  														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 					SCREAMING_SNAKE_CASE( self       :str    )     ->Optional[int]:
  										lowercase    ,  lowercase						    =			self.model_tester.prepare_config_and_inputs_for_common()
  										lowercase						    =			True
  
  										for model_class in self.all_model_classes:
  														lowercase						    =			True
  														lowercase						    =			False
  														lowercase						    =			True
  														lowercase						    =			model_class(lowerCAmelCase__    )
  														model.to(lowerCAmelCase__    )
  														model.eval()
  														with torch.no_grad():
  																		lowercase						    =			model(**self._prepare_for_class(lowerCAmelCase__		,						lowerCAmelCase__    )    )
  														lowercase						    =			outputs.attentions
  														lowercase						    =			len(self.model_tester.depths    )
  														self.assertEqual(len(lowerCAmelCase__    )		,						lowerCAmelCase__    )
  
  														# check that output_attentions also work using config
  														del inputs_dict["output_attentions"]
  														lowercase						    =			True
  														lowercase						    =			config.window_size**2
  														lowercase						    =			model_class(lowerCAmelCase__    )
  														model.to(lowerCAmelCase__    )
  														model.eval()
  														with torch.no_grad():
  																		lowercase						    =			model(**self._prepare_for_class(lowerCAmelCase__		,						lowerCAmelCase__    )    )
  														lowercase						    =			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]		,						)
  														lowercase						    =			len(lowerCAmelCase__    )
  
  														# Check attention is always last and order is fine
  														lowercase						    =			True
  														lowercase						    =			True
  														lowercase						    =			model_class(lowerCAmelCase__    )
  														model.to(lowerCAmelCase__    )
  														model.eval()
  														with torch.no_grad():
  																		lowercase						    =			model(**self._prepare_for_class(lowerCAmelCase__		,						lowerCAmelCase__    )    )
  
  														self.assertEqual(out_len + 1		,						len(lowerCAmelCase__    )    )
  
  														lowercase						    =			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]		,						)
  
  
  
  
  
  @require_vision
  @require_torch
  @slow
  class      UpperCamelCase_			(			unittest.TestCase		):
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :List[str]    )     ->int:
  										lowercase						    =			SwinaSRImageProcessor()
  										lowercase						    =			SwinaSRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64"    ).to(lowerCAmelCase__    )
  
  										lowercase						    =			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
  										lowercase						    =			processor(images=lowerCAmelCase__		,						return_tensors="pt"    ).to(lowerCAmelCase__    )
  
  										# forward pass
  										with torch.no_grad():
  														lowercase						    =			model(**lowerCAmelCase__    )
  
  										# verify the logits
  										lowercase						    =			torch.Size([1, 3, 976, 1296]    )
  										self.assertEqual(outputs.reconstruction.shape		,						lowerCAmelCase__    )
  										lowercase						    =			torch.tensor(
  										    [[0.54_58, 0.55_46, 0.56_38], [0.55_26, 0.55_65, 0.56_51], [0.53_96, 0.54_26, 0.56_21]]    ).to(lowerCAmelCase__    )
  										self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]		,						lowerCAmelCase__		,						atol=1E-4    )    )
  
style_context: 
  from transformers import PretrainedConfig
  
  
  
  
  
  class      UpperCamelCase_			(			__a		):
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCamelCase			:     List[str]							      =				'''custom'''
  
  
  
  
  
  						def __init__( self       :Tuple		,						lowerCAmelCase__       :int=1		,						**lowerCAmelCase__       :List[Any]    )     ->int:
  										lowercase						    =			attribute
  										super().__init__(**lowerCAmelCase__    )
  
  
  
  
  
  class      UpperCamelCase_			(			__a		):
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCamelCase			:     Union[str, Any]							      =				'''custom'''
  
  
  
  
  
  						def __init__( self       :Union[str, Any]		,						lowerCAmelCase__       :Dict=1		,						**lowerCAmelCase__       :Dict    )     ->List[str]:
  										lowercase						    =			attribute
  