


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







						'''simple docstring'''




						def __init__(					self ,    __lowercase ,    __lowercase=1_3 ,    __lowercase=3_2 ,    __lowercase=1 ,    __lowercase=3 ,    __lowercase=1_6 ,    __lowercase=[1, 2, 1] ,    __lowercase=[2, 2, 4] ,    __lowercase=2 ,    __lowercase=2.0 ,    __lowercase=True ,    __lowercase=0.0 ,    __lowercase=0.0 ,    __lowercase=0.1 ,    __lowercase="gelu" ,    __lowercase=False ,    __lowercase=True ,    __lowercase=0.02 ,    __lowercase=1e-5 ,    __lowercase=True ,    __lowercase=None ,    __lowercase=False ,    __lowercase=2 ,    )       ->     List[str]:
										lowerCAmelCase_			:   Optional[int]     					=					parent
										lowerCAmelCase_			:   Optional[int]     					=					batch_size
										lowerCAmelCase_			:   Optional[Any]     					=					image_size
										lowerCAmelCase_			:   Optional[int]     					=					patch_size
										lowerCAmelCase_			:   Tuple     					=					num_channels
										lowerCAmelCase_			:   int     					=					embed_dim
										lowerCAmelCase_			:   Optional[int]     					=					depths
										lowerCAmelCase_			:   List[Any]     					=					num_heads
										lowerCAmelCase_			:   List[Any]     					=					window_size
										lowerCAmelCase_			:   List[Any]     					=					mlp_ratio
										lowerCAmelCase_			:   str     					=					qkv_bias
										lowerCAmelCase_			:   Optional[int]     					=					hidden_dropout_prob
										lowerCAmelCase_			:   List[str]     					=					attention_probs_dropout_prob
										lowerCAmelCase_			:   str     					=					drop_path_rate
										lowerCAmelCase_			:   Dict     					=					hidden_act
										lowerCAmelCase_			:   List[Any]     					=					use_absolute_embeddings
										lowerCAmelCase_			:   int     					=					patch_norm
										lowerCAmelCase_			:   str     					=					layer_norm_eps
										lowerCAmelCase_			:   Optional[Any]     					=					initializer_range
										lowerCAmelCase_			:   List[Any]     					=					is_training
										lowerCAmelCase_			:   Union[str, Any]     					=					scope
										lowerCAmelCase_			:   Optional[int]     					=					use_labels
										lowerCAmelCase_			:   str     					=					upscale

										# here we set some attributes to make tests pass
										lowerCAmelCase_			:   List[Any]     					=					len(__lowercase				)
										lowerCAmelCase_			:   int     					=					embed_dim
										lowerCAmelCase_			:   Tuple     					=					(image_size // patch_size) ** 2




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

										lowerCAmelCase_			:   Optional[int]     					=					None
										if self.use_labels:
														lowerCAmelCase_			:   Optional[int]     					=					ids_tensor([self.batch_size] ,    self.type_sequence_label_size				)

										lowerCAmelCase_			:   Optional[int]     					=					self.get_config()

										return config, pixel_values, labels




						def     lowercase_			(					self				)       ->     str:
										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     lowercase_			(					self ,    __lowercase ,    __lowercase ,    __lowercase				)       ->     Tuple:
										lowerCAmelCase_			:   str     					=					SwinaSRModel(config=__lowercase				)
										model.to(__lowercase				)
										model.eval()
										lowerCAmelCase_			:   Optional[Any]     					=					model(__lowercase				)

										self.parent.assertEqual(
										    result.last_hidden_state.shape ,    (self.batch_size, self.embed_dim, self.image_size, self.image_size)				)




						def     lowercase_			(					self ,    __lowercase ,    __lowercase ,    __lowercase				)       ->     Any:
										lowerCAmelCase_			:   List[str]     					=					SwinaSRForImageSuperResolution(__lowercase				)
										model.to(__lowercase				)
										model.eval()
										lowerCAmelCase_			:   List[Any]     					=					model(__lowercase				)

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




						def     lowercase_			(					self				)       ->     str:
										lowerCAmelCase_			:   Tuple     					=					self.prepare_config_and_inputs()
										lowerCAmelCase_					,	lowerCAmelCase_					,	lowerCAmelCase_			:   Optional[Any]     					=					config_and_inputs
										lowerCAmelCase_			:   Optional[int]     					=					{'''pixel_values''': pixel_values}
										return config, inputs_dict







@require_torch
class 					snake_case__(				UpperCAmelCase__,    UpperCAmelCase__,    unittest.TestCase				):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__   :	Optional[Any]       =				(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
						SCREAMING_SNAKE_CASE__   :	Any       =				{"""feature-extraction""": SwinaSRModel} if is_torch_available() else {}

						SCREAMING_SNAKE_CASE__   :	Optional[int]       =				False
						SCREAMING_SNAKE_CASE__   :	Dict       =				False
						SCREAMING_SNAKE_CASE__   :	Tuple       =				False
						SCREAMING_SNAKE_CASE__   :	str       =				False
						SCREAMING_SNAKE_CASE__   :	Dict       =				False




						def     lowercase_			(					self				)       ->     Optional[int]:
										lowerCAmelCase_			:   int     					=					SwinaSRModelTester(self				)
										lowerCAmelCase_			:   Tuple     					=					ConfigTester(self ,    config_class=__lowercase ,    embed_dim=3_7				)




						def     lowercase_			(					self				)       ->     Union[str, 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     lowercase_			(					self				)       ->     List[str]:
										lowerCAmelCase_			:   List[str]     					=					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__lowercase				)




						def     lowercase_			(					self				)       ->     Any:
										lowerCAmelCase_			:   Optional[int]     					=					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_super_resolution(*__lowercase				)




						@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''				)
						def     lowercase_			(					self				)       ->     Dict:
										pass




						@unittest.skip(reason='''Swin2SR does not use inputs_embeds'''				)
						def     lowercase_			(					self				)       ->     Dict:
										pass




						@unittest.skip(reason='''Swin2SR does not support training yet'''				)
						def     lowercase_			(					self				)       ->     List[str]:
										pass




						@unittest.skip(reason='''Swin2SR does not support training yet'''				)
						def     lowercase_			(					self				)       ->     Union[str, Any]:
										pass




						def     lowercase_			(					self				)       ->     Optional[Any]:
										lowerCAmelCase_					,	lowerCAmelCase_			:   List[str]     					=					self.model_tester.prepare_config_and_inputs_for_common()

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




						def     lowercase_			(					self				)       ->     Union[str, Any]:
										lowerCAmelCase_					,	lowerCAmelCase_			:   str     					=					self.model_tester.prepare_config_and_inputs_for_common()

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

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




						@slow
						def     lowercase_			(					self				)       ->     Tuple:
										for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCAmelCase_			:   List[str]     					=					SwinaSRModel.from_pretrained(__lowercase				)
														self.assertIsNotNone(__lowercase				)




						def     lowercase_			(					self				)       ->     Optional[int]:
										lowerCAmelCase_					,	lowerCAmelCase_			:   Tuple     					=					self.model_tester.prepare_config_and_inputs_for_common()

										lowerCAmelCase_			:   List[Any]     					=					_config_zero_init(__lowercase				)
										for model_class in self.all_model_classes:
														lowerCAmelCase_			:   List[str]     					=					model_class(config=__lowercase				)
														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     lowercase_			(					self				)       ->     Tuple:
										lowerCAmelCase_					,	lowerCAmelCase_			:   str     					=					self.model_tester.prepare_config_and_inputs_for_common()
										lowerCAmelCase_			:   Optional[int]     					=					True

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

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

														self.assertListEqual(
														    list(attentions[0].shape[-3:]				) ,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,    )
														lowerCAmelCase_			:   List[Any]     					=					len(__lowercase				)

														# Check attention is always last and order is fine
														lowerCAmelCase_			:   int     					=					True
														lowerCAmelCase_			:   Union[str, Any]     					=					True
														lowerCAmelCase_			:   Dict     					=					model_class(__lowercase				)
														model.to(__lowercase				)
														model.eval()
														with torch.no_grad():
																		lowerCAmelCase_			:   int     					=					model(**self._prepare_for_class(__lowercase ,    __lowercase				)				)

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

														lowerCAmelCase_			:   Optional[int]     					=					outputs.attentions

														self.assertEqual(len(__lowercase				) ,    __lowercase				)

														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 					snake_case__(				unittest.TestCase				):







						'''simple docstring'''




						def     lowercase_			(					self				)       ->     Optional[Any]:
										lowerCAmelCase_			:   List[Any]     					=					SwinaSRImageProcessor()
										lowerCAmelCase_			:   int     					=					SwinaSRForImageSuperResolution.from_pretrained('''caidas/swin2SR-classical-sr-x2-64'''				).to(__lowercase				)

										lowerCAmelCase_			:   List[str]     					=					Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
										lowerCAmelCase_			:   Optional[Any]     					=					processor(images=__lowercase ,    return_tensors='''pt'''				).to(__lowercase				)

										# forward pass
										with torch.no_grad():
														lowerCAmelCase_			:   Optional[Any]     					=					model(**__lowercase				)

										# verify the logits
										lowerCAmelCase_			:   List[str]     					=					torch.Size([1, 3, 9_7_6, 1_2_9_6]				)
										self.assertEqual(outputs.reconstruction.shape ,    __lowercase				)
										lowerCAmelCase_			:   int     					=					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(__lowercase				)
										self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3] ,    __lowercase ,    atol=1e-4				)				)



from transformers import PretrainedConfig







class 					snake_case__(				UpperCAmelCase__				):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__   :	Optional[int]       =				"""custom"""




						def __init__(					self ,    __lowercase=1 ,    **__lowercase				)       ->     Dict:
										lowerCAmelCase_			:   List[Any]     					=					attribute
										super().__init__(**__lowercase				)







class 					snake_case__(				UpperCAmelCase__				):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__   :	int       =				"""custom"""




						def __init__(					self ,    __lowercase=1 ,    **__lowercase				)       ->     List[Any]:
										lowerCAmelCase_			:   Optional[Any]     					=					attribute