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



   '''simple docstring'''



   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(lowercase_	)
      __lowerCamelCase    		=					embed_dim
      __lowerCamelCase    		=					(image_size // patch_size) ** 2







   def    _A				(	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    _A				(	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    _A				(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					SwinaSRModel(config=lowercase_	)
      model.to(lowercase_	)
      model.eval()
      __lowerCamelCase    		=					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 ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					SwinaSRForImageSuperResolution(lowercase_	)
      model.to(lowercase_	)
      model.eval()
      __lowerCamelCase    		=					model(lowercase_	)

      __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    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.prepare_config_and_inputs()
      __lowerCamelCase    		=					config_and_inputs
      __lowerCamelCase    		=					{"pixel_values": pixel_values}
      return config, inputs_dict






@require_torch
class      _SCREAMING_SNAKE_CASE							(			lowercase__    ,				lowercase__    ,				unittest.TestCase				):



   '''simple docstring'''



   __UpperCAmelCase	:							int    =    (SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
   __UpperCAmelCase	:							List[Any]    =    {"""feature-extraction""": SwinaSRModel} if is_torch_available() else {}

   __UpperCAmelCase	:							Tuple    =    False
   __UpperCAmelCase	:							Dict    =    False
   __UpperCAmelCase	:							Optional[int]    =    False
   __UpperCAmelCase	:							str    =    False
   __UpperCAmelCase	:							List[str]    =    False







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					SwinaSRModelTester(self	)
      __lowerCamelCase    		=					ConfigTester(self ,				config_class=lowercase_ ,				embed_dim=37	)







   def    _A				(	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    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowercase_	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					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	):


      '''simple docstring'''

      pass







   @unittest.skip(reason='Swin2SR does not use inputs_embeds'	)
   def    _A				(	self	):


      '''simple docstring'''

      pass







   @unittest.skip(reason='Swin2SR does not support training yet'	)
   def    _A				(	self	):


      '''simple docstring'''

      pass







   @unittest.skip(reason='Swin2SR does not support training yet'	)
   def    _A				(	self	):


      '''simple docstring'''

      pass







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __lowerCamelCase    		=					model_class(lowercase_	)
         self.assertIsInstance(model.get_input_embeddings() ,				(nn.Module)	)
         __lowerCamelCase    		=					model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(lowercase_ ,				nn.Linear	)	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __lowerCamelCase    		=					model_class(lowercase_	)
         __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] ,				lowercase_	)







   @slow
   def    _A				(	self	):


      '''simple docstring'''

      for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __lowerCamelCase    		=					SwinaSRModel.from_pretrained(lowercase_	)
         self.assertIsNotNone(lowercase_	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					self.model_tester.prepare_config_and_inputs_for_common()

      __lowerCamelCase    		=					_config_zero_init(lowercase_	)
      for model_class in self.all_model_classes:
         __lowerCamelCase    		=					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	):


      '''simple docstring'''

      __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(lowercase_	)
         model.to(lowercase_	)
         model.eval()
         with torch.no_grad():
            __lowerCamelCase    		=					model(**self._prepare_for_class(lowercase_ ,				lowercase_	)	)
         __lowerCamelCase    		=					outputs.attentions
         __lowerCamelCase    		=					len(self.model_tester.depths	)
         self.assertEqual(len(lowercase_	) ,				lowercase_	)

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         __lowerCamelCase    		=					True
         __lowerCamelCase    		=					config.window_size**2
         __lowerCamelCase    		=					model_class(lowercase_	)
         model.to(lowercase_	)
         model.eval()
         with torch.no_grad():
            __lowerCamelCase    		=					model(**self._prepare_for_class(lowercase_ ,				lowercase_	)	)
         __lowerCamelCase    		=					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    		=					len(lowercase_	)

         # Check attention is always last and order is fine
         __lowerCamelCase    		=					True
         __lowerCamelCase    		=					True
         __lowerCamelCase    		=					model_class(lowercase_	)
         model.to(lowercase_	)
         model.eval()
         with torch.no_grad():
            __lowerCamelCase    		=					model(**self._prepare_for_class(lowercase_ ,				lowercase_	)	)

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

         __lowerCamelCase    		=					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      _SCREAMING_SNAKE_CASE							(			unittest.TestCase				):



   '''simple docstring'''



   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					SwinaSRImageProcessor()
      __lowerCamelCase    		=					SwinaSRForImageSuperResolution.from_pretrained('caidas/swin2SR-classical-sr-x2-64'	).to(lowercase_	)

      __lowerCamelCase    		=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
      __lowerCamelCase    		=					processor(images=lowercase_ ,				return_tensors='pt'	).to(lowercase_	)

      # forward pass
      with torch.no_grad():
         __lowerCamelCase    		=					model(**lowercase_	)

      # verify the logits
      __lowerCamelCase    		=					torch.Size([1, 3, 976, 1296]	)
      self.assertEqual(outputs.reconstruction.shape ,				lowercase_	)
      __lowerCamelCase    		=					torch.tensor(
          [[0.5458, 0.5546, 0.5638], [0.5526, 0.5565, 0.5651], [0.5396, 0.5426, 0.5621]]	).to(lowercase_	)
      self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3] ,				lowercase_ ,				atol=1E-4	)	)








"""simple docstring"""





import math
from timeit import timeit







def       __a	(						__lowerCamelCase    ):
   UpperCAmelCase_   :   Tuple     	=       0
   UpperCAmelCase_   :   Any     	=       abs(__lowerCamelCase    )
   while True:
      UpperCAmelCase_   :   Optional[int]     	=       n // 10
      digits += 1
      if n == 0:
         break
   return digits







def       __a	(						__lowerCamelCase    ):
   return 1 if n == 0 else math.floor(math.log(abs(__lowerCamelCase    ),						10    ) + 1    )







def       __a	(						__lowerCamelCase    ):
   return len(str(abs(__lowerCamelCase    )    )    )







def       __a	(						):
   from collections.abc import Callable

   def benchmark_a_function(__lowerCamelCase,						__lowerCamelCase    ) -> None:
      UpperCAmelCase_   :   Optional[Any]     	=       f"""{func.__name__}({value})"""
      UpperCAmelCase_   :   Optional[int]     	=       timeit(f"""__main__.{call}""",						setup="import __main__"    )
      print(f"""{call}: {func(__lowerCamelCase    )} -- {timing} seconds"""    )

   for value in (26_2144, 1125_8999_0684_2624, 126_7650_6002_2822_9401_4967_0320_5376):
      for func in (num_digits, num_digits_fast, num_digits_faster):
         benchmark_a_function(__lowerCamelCase,						__lowerCamelCase    )
      print()


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()


