






"""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 						_a  :





   '''simple docstring'''






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




          '''simple docstring'''




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

          # here we set some attributes to make tests pass
          lowercase__:							Dict         =     len(UpperCamelCase__)
          lowercase__:							List[Any]         =     embed_dim
          lowercase__:							Dict         =     (image_size // patch_size) ** 2





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




          '''simple docstring'''




          lowercase__:							Tuple         =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

          lowercase__:							List[str]         =     None
          if self.use_labels:
                 lowercase__:							Tuple         =     ids_tensor([self.batch_size]					, self.type_sequence_label_size)

          lowercase__:							List[str]         =     self.get_config()

          return config, pixel_values, labels





   def __lowercase							(       self)			->   List[Any]:




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




          '''simple docstring'''




          lowercase__:							Tuple         =     SwinaSRModel(config=UpperCamelCase__)
          model.to(UpperCamelCase__)
          model.eval()
          lowercase__:							int         =     model(UpperCamelCase__)

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





   def __lowercase							(       self					, UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_)			->   Any:




          '''simple docstring'''




          lowercase__:							Tuple         =     SwinaSRForImageSuperResolution(UpperCamelCase__)
          model.to(UpperCamelCase__)
          model.eval()
          lowercase__:							str         =     model(UpperCamelCase__)

          lowercase__:							Optional[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)			->   List[Any]:




          '''simple docstring'''




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







@require_torch
class 						_a  (		SCREAMING_SNAKE_CASE_							,	SCREAMING_SNAKE_CASE_							,	unittest.TestCase       ):





   '''simple docstring'''






   UpperCamelCase__     	=							(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
   UpperCamelCase__     	=							{"""feature-extraction""": SwinaSRModel} if is_torch_available() else {}

   UpperCamelCase__     	=							False
   UpperCamelCase__     	=							False
   UpperCamelCase__     	=							False
   UpperCamelCase__     	=							False
   UpperCamelCase__     	=							False





   def __lowercase							(       self)			->   Any:




          '''simple docstring'''




          lowercase__:							Optional[Any]         =     SwinaSRModelTester(self)
          lowercase__:							Optional[int]         =     ConfigTester(self					, config_class=UpperCamelCase__					, embed_dim=37)





   def __lowercase							(       self)			->   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 __lowercase							(       self)			->   Optional[Any]:




          '''simple docstring'''




          lowercase__:							Union[str, Any]         =     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*UpperCamelCase__)





   def __lowercase							(       self)			->   Dict:




          '''simple docstring'''




          lowercase__:							Optional[Any]         =     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_super_resolution(*UpperCamelCase__)





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




          '''simple docstring'''




          pass





   @unittest.skip(reason="Swin2SR does not use inputs_embeds")
   def __lowercase							(       self)			->   str:




          '''simple docstring'''




          pass





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




          '''simple docstring'''




          pass





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




          '''simple docstring'''




          pass





   def __lowercase							(       self)			->   Optional[Any]:




          '''simple docstring'''




          lowercase__:							Any         =     self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                 lowercase__:							Tuple         =     model_class(UpperCamelCase__)
                 self.assertIsInstance(model.get_input_embeddings()					, (nn.Module))
                 lowercase__:							Union[str, Any]         =     model.get_output_embeddings()
                 self.assertTrue(x is None or isinstance(UpperCamelCase__					, nn.Linear))





   def __lowercase							(       self)			->   Optional[Any]:




          '''simple docstring'''




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

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

                 lowercase__:							int         =     ['''pixel_values''']
                 self.assertListEqual(arg_names[:1]					, UpperCamelCase__)





   @slow
   def __lowercase							(       self)			->   List[str]:




          '''simple docstring'''




          for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 lowercase__:							int         =     SwinaSRModel.from_pretrained(UpperCamelCase__)
                 self.assertIsNotNone(UpperCamelCase__)





   def __lowercase							(       self)			->   Any:




          '''simple docstring'''




          lowercase__:							Union[str, Any]         =     self.model_tester.prepare_config_and_inputs_for_common()

          lowercase__:							Any         =     _config_zero_init(UpperCamelCase__)
          for model_class in self.all_model_classes:
                 lowercase__:							Dict         =     model_class(config=UpperCamelCase__)
                 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)			->   Optional[Any]:




          '''simple docstring'''




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

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

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

                 self.assertListEqual(
                     list(attentions[0].shape[-3:])					, [self.model_tester.num_heads[0], window_size_squared, window_size_squared]					, )
                 lowercase__:							Optional[int]         =     len(UpperCamelCase__)

                 # Check attention is always last and order is fine
                 lowercase__:							Tuple         =     True
                 lowercase__:							Optional[Any]         =     True
                 lowercase__:							Optional[int]         =     model_class(UpperCamelCase__)
                 model.to(UpperCamelCase__)
                 model.eval()
                 with torch.no_grad():
                        lowercase__:							Optional[int]         =     model(**self._prepare_for_class(UpperCamelCase__					, UpperCamelCase__))

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

                 lowercase__:							Optional[int]         =     outputs.attentions

                 self.assertEqual(len(UpperCamelCase__)					, UpperCamelCase__)

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





   '''simple docstring'''






   def __lowercase							(       self)			->   int:




          '''simple docstring'''




          lowercase__:							List[Any]         =     SwinaSRImageProcessor()
          lowercase__:							Union[str, Any]         =     SwinaSRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64").to(UpperCamelCase__)

          lowercase__:							int         =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
          lowercase__:							Dict         =     processor(images=UpperCamelCase__					, return_tensors="pt").to(UpperCamelCase__)

          # forward pass
          with torch.no_grad():
                 lowercase__:							int         =     model(**UpperCamelCase__)

          # verify the logits
          lowercase__:							Any         =     torch.Size([1, 3, 976, 1_296])
          self.assertEqual(outputs.reconstruction.shape					, UpperCamelCase__)
          lowercase__:							List[Any]         =     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(UpperCamelCase__)
          self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]					, UpperCamelCase__					, atol=1E-4))








def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    Dict				,    __UpperCamelCase			:    Dict							)			->							List[Any]:

				"""simple docstring"""







				if len(str(__UpperCamelCase							)							) == 1 or len(str(__UpperCamelCase							)							) == 1:
								return a * b

				A__	:						List[str]								=				max(len(str(__UpperCamelCase							)							)				,    len(str(__UpperCamelCase							)							)							)
				A__	:						Any								=				ma // 2

				A__							,				A__	:						Union[str, Any]								=				divmod(__UpperCamelCase				,    10**ma							)
				A__							,				A__	:						Tuple								=				divmod(__UpperCamelCase				,    10**ma							)

				A__	:						Optional[int]								=				karatsuba(__UpperCamelCase				,    __UpperCamelCase							)
				A__	:						Tuple								=				karatsuba((aa + aa)				,    (ba + ba)							)
				A__	:						Optional[int]								=				karatsuba(__UpperCamelCase				,    __UpperCamelCase							)

				return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)

def 					SCREAMING_SNAKE_CASE  (   )			->							Dict:

				"""simple docstring"""







				print(karatsuba(1_54_63				,    2_34_89							)							)


if __name__ == "__main__":
					main()