


'''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        UpperCAmelCase_  :





    """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.0_2      ,					SCREAMING_SNAKE_CASE_=1E-5      ,					SCREAMING_SNAKE_CASE_=True      ,					SCREAMING_SNAKE_CASE_=None      ,					SCREAMING_SNAKE_CASE_=False      ,					SCREAMING_SNAKE_CASE_=2      ,					)    ->					List[Any]:
         __lowerCamelCase       :     Union[str, Any]        =		parent
         __lowerCamelCase       :     Union[str, Any]        =		batch_size
         __lowerCamelCase       :     Tuple        =		image_size
         __lowerCamelCase       :     List[str]        =		patch_size
         __lowerCamelCase       :     Tuple        =		num_channels
         __lowerCamelCase       :     Union[str, Any]        =		embed_dim
         __lowerCamelCase       :     List[str]        =		depths
         __lowerCamelCase       :     List[str]        =		num_heads
         __lowerCamelCase       :     Optional[int]        =		window_size
         __lowerCamelCase       :     Union[str, Any]        =		mlp_ratio
         __lowerCamelCase       :     Optional[Any]        =		qkv_bias
         __lowerCamelCase       :     Optional[int]        =		hidden_dropout_prob
         __lowerCamelCase       :     Union[str, Any]        =		attention_probs_dropout_prob
         __lowerCamelCase       :     Dict        =		drop_path_rate
         __lowerCamelCase       :     Dict        =		hidden_act
         __lowerCamelCase       :     Any        =		use_absolute_embeddings
         __lowerCamelCase       :     List[Any]        =		patch_norm
         __lowerCamelCase       :     List[str]        =		layer_norm_eps
         __lowerCamelCase       :     Optional[int]        =		initializer_range
         __lowerCamelCase       :     Tuple        =		is_training
         __lowerCamelCase       :     Optional[int]        =		scope
         __lowerCamelCase       :     int        =		use_labels
         __lowerCamelCase       :     str        =		upscale

         # here we set some attributes to make tests pass
         __lowerCamelCase       :     str        =		len(SCREAMING_SNAKE_CASE_     )
         __lowerCamelCase       :     int        =		embed_dim
         __lowerCamelCase       :     Tuple        =		(image_size // patch_size) ** 2







    def 				lowercase_    (							self     )    ->					Union[str, Any]:
         __lowerCamelCase       :     int        =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

         __lowerCamelCase       :     Dict        =		self.get_config()

         return config, pixel_values, labels







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

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







    def 				lowercase_    (							self      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_     )    ->					List[Any]:
         __lowerCamelCase       :     Optional[Any]        =		SwinaSRForImageSuperResolution(SCREAMING_SNAKE_CASE_     )
         model.to(SCREAMING_SNAKE_CASE_     )
         model.eval()
         __lowerCamelCase       :     Any        =		model(SCREAMING_SNAKE_CASE_     )

         __lowerCamelCase       :     List[str]        =		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     )    ->					Union[str, Any]:
         __lowerCamelCase       :     Tuple        =		self.prepare_config_and_inputs()
         __lowerCamelCase    ,	__lowerCamelCase    ,	__lowerCamelCase       :     List[str]        =		config_and_inputs
         __lowerCamelCase       :     str        =		{'pixel_values': pixel_values}
         return config, inputs_dict







@require_torch
class        UpperCAmelCase_  (_UpperCAmelCase ,		_UpperCAmelCase ,		unittest.TestCase  ):





    """simple docstring"""






    lowerCamelCase  : Union[str, Any]												=      (SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
    lowerCamelCase  : Any												=      {'feature-extraction': SwinaSRModel} if is_torch_available() else {}

    lowerCamelCase  : Any												=      False
    lowerCamelCase  : Dict												=      False
    lowerCamelCase  : Optional[Any]												=      False
    lowerCamelCase  : Union[str, Any]												=      False
    lowerCamelCase  : Any												=      False







    def 				lowercase_    (							self     )    ->					Optional[Any]:
         __lowerCamelCase       :     Any        =		SwinaSRModelTester(self     )
         __lowerCamelCase       :     Dict        =		ConfigTester(self      ,					config_class=SCREAMING_SNAKE_CASE_      ,					embed_dim=37     )







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







    def 				lowercase_    (							self     )    ->					int:
         __lowerCamelCase       :     List[str]        =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_super_resolution(*SCREAMING_SNAKE_CASE_     )







    @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     )    ->					Any:
         pass







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







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







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

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







    def 				lowercase_    (							self     )    ->					Dict:
         __lowerCamelCase    ,	__lowerCamelCase       :     List[str]        =		self.model_tester.prepare_config_and_inputs_for_common()

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

              __lowerCamelCase       :     Optional[int]        =		['pixel_values']
              self.assertListEqual(arg_names[:1]      ,					SCREAMING_SNAKE_CASE_     )







    @slow
    def 				lowercase_    (							self     )    ->					Optional[int]:
         for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              __lowerCamelCase       :     Union[str, Any]        =		SwinaSRModel.from_pretrained(SCREAMING_SNAKE_CASE_     )
              self.assertIsNotNone(SCREAMING_SNAKE_CASE_     )







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

         __lowerCamelCase       :     List[str]        =		_config_zero_init(SCREAMING_SNAKE_CASE_     )
         for model_class in self.all_model_classes:
              __lowerCamelCase       :     List[str]        =		model_class(config=SCREAMING_SNAKE_CASE_     )
              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     )    ->					Dict:
         __lowerCamelCase    ,	__lowerCamelCase       :     Optional[Any]        =		self.model_tester.prepare_config_and_inputs_for_common()
         __lowerCamelCase       :     List[Any]        =		True

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

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

              self.assertListEqual(
                  list(attentions[0].shape[-3:]     )      ,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]      ,					)
              __lowerCamelCase       :     Optional[Any]        =		len(SCREAMING_SNAKE_CASE_     )

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

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

              __lowerCamelCase       :     Optional[int]        =		outputs.attentions

              self.assertEqual(len(SCREAMING_SNAKE_CASE_     )      ,					SCREAMING_SNAKE_CASE_     )

              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 				lowercase_    (							self     )    ->					List[str]:
         __lowerCamelCase       :     Optional[int]        =		SwinaSRImageProcessor()
         __lowerCamelCase       :     Union[str, Any]        =		SwinaSRForImageSuperResolution.from_pretrained('caidas/swin2SR-classical-sr-x2-64'     ).to(SCREAMING_SNAKE_CASE_     )

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

         # forward pass
         with torch.no_grad():
              __lowerCamelCase       :     List[Any]        =		model(**SCREAMING_SNAKE_CASE_     )

         # verify the logits
         __lowerCamelCase       :     List[str]        =		torch.Size([1, 3, 9_76, 12_96]     )
         self.assertEqual(outputs.reconstruction.shape      ,					SCREAMING_SNAKE_CASE_     )
         __lowerCamelCase       :     Any        =		torch.tensor(
             [[0.5_4_5_8, 0.5_5_4_6, 0.5_6_3_8], [0.5_5_2_6, 0.5_5_6_5, 0.5_6_5_1], [0.5_3_9_6, 0.5_4_2_6, 0.5_6_2_1]]     ).to(SCREAMING_SNAKE_CASE_     )
         self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]      ,					SCREAMING_SNAKE_CASE_      ,					atol=1E-4     )     )










'''simple docstring'''



def       UpperCAmelCase__ (     UpperCAmelCase_   :    int = 4_00_00_00							)					->		int:
     __lowerCamelCase       :     int        =		1
     __lowerCamelCase       :     Union[str, Any]        =		2
     __lowerCamelCase       :     Optional[int]        =		0
     while j <= n:
          if j % 2 == 0:
               total += j
          __lowerCamelCase    ,	__lowerCamelCase       :     List[Any]        =		j, i + j

     return total


if __name__ == "__main__":
      print(f'''{solution() = }''')






