



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







		def __init__(    self  :   Dict       ,		UpperCAmelCase_  :   int       ,		UpperCAmelCase_  :   Tuple=13       ,		UpperCAmelCase_  :   str=32       ,		UpperCAmelCase_  :   List[Any]=1       ,		UpperCAmelCase_  :   Dict=3       ,		UpperCAmelCase_  :   List[Any]=16       ,		UpperCAmelCase_  :   List[str]=[1, 2, 1]       ,		UpperCAmelCase_  :   Optional[Any]=[2, 2, 4]       ,		UpperCAmelCase_  :   List[str]=2       ,		UpperCAmelCase_  :   Any=2.0       ,		UpperCAmelCase_  :   Dict=True       ,		UpperCAmelCase_  :   List[Any]=0.0       ,		UpperCAmelCase_  :   Union[str, Any]=0.0       ,		UpperCAmelCase_  :   Dict=0.1       ,		UpperCAmelCase_  :   Tuple="gelu"       ,		UpperCAmelCase_  :   Tuple=False       ,		UpperCAmelCase_  :   Union[str, Any]=True       ,		UpperCAmelCase_  :   Optional[int]=0.02       ,		UpperCAmelCase_  :   Optional[Any]=1E-5       ,		UpperCAmelCase_  :   Optional[int]=True       ,		UpperCAmelCase_  :   str=None       ,		UpperCAmelCase_  :   Optional[Any]=False       ,		UpperCAmelCase_  :   Optional[int]=2       ,		)       ->		List[str]:


						'''simple docstring'''







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

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







		def 					a_  (    self  :   List[str]					)       ->		Optional[int]:


						'''simple docstring'''







						_UpperCAmelCase						:  int     					=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

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

						return config, pixel_values, labels







		def 					a_  (    self  :   Optional[Any]					)       ->		str:


						'''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 					a_  (    self  :   List[Any]       ,		UpperCAmelCase_  :   Union[str, Any]       ,		UpperCAmelCase_  :   str       ,		UpperCAmelCase_  :   List[Any]					)       ->		Tuple:


						'''simple docstring'''







						_UpperCAmelCase						:  str     					=	SwinaSRModel(config=__lowercase					)
						model.to(__lowercase					)
						model.eval()
						_UpperCAmelCase						:  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 					a_  (    self  :   Union[str, Any]       ,		UpperCAmelCase_  :   List[Any]       ,		UpperCAmelCase_  :   Optional[Any]       ,		UpperCAmelCase_  :   Optional[int]					)       ->		Any:


						'''simple docstring'''







						_UpperCAmelCase						:  List[str]     					=	SwinaSRForImageSuperResolution(__lowercase					)
						model.to(__lowercase					)
						model.eval()
						_UpperCAmelCase						:  List[Any]     					=	model(__lowercase					)

						_UpperCAmelCase						:  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 					a_  (    self  :   Dict					)       ->		str:


						'''simple docstring'''







						_UpperCAmelCase						:  Tuple     					=	self.prepare_config_and_inputs()
						_UpperCAmelCase						:  Optional[Any]     					=	config_and_inputs
						_UpperCAmelCase						:  Optional[int]     					=	{'''pixel_values''': pixel_values}
						return config, inputs_dict





@require_torch
class 							lowerCAmelCase_		(		UpperCAmelCase__							,		UpperCAmelCase__							,		unittest.TestCase     ):
		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 					a_  (    self  :   Any					)       ->		Optional[int]:


						'''simple docstring'''







						_UpperCAmelCase						:  int     					=	SwinaSRModelTester(self					)
						_UpperCAmelCase						:  Tuple     					=	ConfigTester(self       ,		config_class=__lowercase       ,		embed_dim=37					)







		def 					a_  (    self  :   Optional[Any]					)       ->		Union[str, 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 					a_  (    self  :   Optional[int]					)       ->		List[str]:


						'''simple docstring'''







						_UpperCAmelCase						:  List[str]     					=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__lowercase					)







		def 					a_  (    self  :   int					)       ->		Any:


						'''simple docstring'''







						_UpperCAmelCase						:  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 					a_  (    self  :   Any					)       ->		Dict:


						'''simple docstring'''







						pass







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


						'''simple docstring'''







						pass







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


						'''simple docstring'''







						pass







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


						'''simple docstring'''







						pass







		def 					a_  (    self  :   Dict					)       ->		Optional[Any]:


						'''simple docstring'''







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

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







		def 					a_  (    self  :   Tuple					)       ->		Union[str, Any]:


						'''simple docstring'''







						_UpperCAmelCase						:  str     					=	self.model_tester.prepare_config_and_inputs_for_common()

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

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







		@slow
		def 					a_  (    self  :   Dict					)       ->		Tuple:


						'''simple docstring'''







						for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										_UpperCAmelCase						:  List[str]     					=	SwinaSRModel.from_pretrained(__lowercase					)
										self.assertIsNotNone(__lowercase					)







		def 					a_  (    self  :   Any					)       ->		Optional[int]:


						'''simple docstring'''







						_UpperCAmelCase						:  Tuple     					=	self.model_tester.prepare_config_and_inputs_for_common()

						_UpperCAmelCase						:  List[Any]     					=	_config_zero_init(__lowercase					)
						for model_class in self.all_model_classes:
										_UpperCAmelCase						:  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 					a_  (    self  :   Dict					)       ->		Tuple:


						'''simple docstring'''







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

						for model_class in self.all_model_classes:
										_UpperCAmelCase						:  str     					=	True
										_UpperCAmelCase						:  Optional[int]     					=	False
										_UpperCAmelCase						:  int     					=	True
										_UpperCAmelCase						:  Any     					=	model_class(__lowercase					)
										model.to(__lowercase					)
										model.eval()
										with torch.no_grad():
														_UpperCAmelCase						:  str     					=	model(**self._prepare_for_class(__lowercase       ,		__lowercase					)					)
										_UpperCAmelCase						:  str     					=	outputs.attentions
										_UpperCAmelCase						:  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"]
										_UpperCAmelCase						:  List[str]     					=	True
										_UpperCAmelCase						:  Tuple     					=	config.window_size**2
										_UpperCAmelCase						:  Tuple     					=	model_class(__lowercase					)
										model.to(__lowercase					)
										model.eval()
										with torch.no_grad():
														_UpperCAmelCase						:  Union[str, Any]     					=	model(**self._prepare_for_class(__lowercase       ,		__lowercase					)					)
										_UpperCAmelCase						:  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]       ,		)
										_UpperCAmelCase						:  List[Any]     					=	len(__lowercase					)

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

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

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







		def 					a_  (    self  :   Optional[int]					)       ->		Optional[Any]:


						'''simple docstring'''







						_UpperCAmelCase						:  List[Any]     					=	SwinaSRImageProcessor()
						_UpperCAmelCase						:  int     					=	SwinaSRForImageSuperResolution.from_pretrained('''caidas/swin2SR-classical-sr-x2-64'''					).to(__lowercase					)

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

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

						# verify the logits
						_UpperCAmelCase						:  List[str]     					=	torch.Size([1, 3, 976, 1296]					)
						self.assertEqual(outputs.reconstruction.shape       ,		__lowercase					)
						_UpperCAmelCase						:  int     					=	torch.tensor(
						    [[0.5_458, 0.5_546, 0.5_638], [0.5_526, 0.5_565, 0.5_651], [0.5_396, 0.5_426, 0.5_621]]					).to(__lowercase					)
						self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]       ,		__lowercase       ,		atol=1E-4					)					)




def       lowerCAmelCase			(		lowerCAmelCase_			)->			int:
				lowerCAmelCase_			:   Optional[int]     					=					len(lowerCAmelCase_			)
				if n in (0, 1):
								return 0
				return sum(query * (n - i - 1) for i, query in enumerate(sorted(lowerCAmelCase_			)			)			)


if __name__ == "__main__":
						import doctest

						doctest.testmod()