





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







  def __init__(		self  ,  lowercase__  ,  lowercase__=13  ,  lowercase__=32  ,  lowercase__=1  ,  lowercase__=3  ,  lowercase__=16  ,  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  ,  )		->    Any:






        """simple docstring"""





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

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







  def 					UpperCAmelCase_					(		self		)		->    int:






        """simple docstring"""





        _snake_case		:						Optional[Any]         =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

        _snake_case		:						int         =  self.get_config()

        return config, pixel_values, labels







  def 					UpperCAmelCase_					(		self		)		->    Tuple:






        """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 					UpperCAmelCase_					(		self  ,  lowercase__  ,  lowercase__  ,  lowercase__		)		->    Any:






        """simple docstring"""





        _snake_case		:						List[Any]         =  SwinaSRModel(config=lowercase__		)
        model.to(lowercase__		)
        model.eval()
        _snake_case		:						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 					UpperCAmelCase_					(		self  ,  lowercase__  ,  lowercase__  ,  lowercase__		)		->    Union[str, Any]:






        """simple docstring"""





        _snake_case		:						Dict         =  SwinaSRForImageSuperResolution(lowercase__		)
        model.to(lowercase__		)
        model.eval()
        _snake_case		:						str         =  model(lowercase__		)

        _snake_case		:						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 					UpperCAmelCase_					(		self		)		->    Union[str, Any]:






        """simple docstring"""





        _snake_case		:						Dict         =  self.prepare_config_and_inputs()
        _snake_case  ,				_snake_case  ,				_snake_case		:						Optional[Any]         =  config_and_inputs
        _snake_case		:						List[str]         =  {'''pixel_values''': pixel_values}
        return config, inputs_dict





@require_torch
class lowerCamelCase    (a__    ,   a__    ,   unittest.TestCase       ):
  _lowercase	:						List[str]							       =					(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
  _lowercase	:						Union[str, Any]							       =					{"""feature-extraction""": SwinaSRModel} if is_torch_available() else {}

  _lowercase	:						Any							       =					False
  _lowercase	:						Union[str, Any]							       =					False
  _lowercase	:						Union[str, Any]							       =					False
  _lowercase	:						Dict							       =					False
  _lowercase	:						List[Any]							       =					False







  def 					UpperCAmelCase_					(		self		)		->    Any:






        """simple docstring"""





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







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






        """simple docstring"""





        _snake_case		:						List[str]         =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowercase__		)







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






        """simple docstring"""





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






        """simple docstring"""





        pass







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






        """simple docstring"""





        pass







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






        """simple docstring"""





        pass







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






        """simple docstring"""





        pass







  def 					UpperCAmelCase_					(		self		)		->    Optional[int]:






        """simple docstring"""





        _snake_case  ,				_snake_case		:						str         =  self.model_tester.prepare_config_and_inputs_for_common()

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







  def 					UpperCAmelCase_					(		self		)		->    int:






        """simple docstring"""





        _snake_case  ,				_snake_case		:						Optional[Any]         =  self.model_tester.prepare_config_and_inputs_for_common()

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

              _snake_case		:						List[Any]         =  ['''pixel_values''']
              self.assertListEqual(arg_names[:1]  ,  lowercase__		)







  @slow
  def 					UpperCAmelCase_					(		self		)		->    Any:






        """simple docstring"""





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







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






        """simple docstring"""





        _snake_case  ,				_snake_case		:						int         =  self.model_tester.prepare_config_and_inputs_for_common()

        _snake_case		:						Any         =  _config_zero_init(lowercase__		)
        for model_class in self.all_model_classes:
              _snake_case		:						int         =  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 					UpperCAmelCase_					(		self		)		->    str:






        """simple docstring"""





        _snake_case  ,				_snake_case		:						Union[str, Any]         =  self.model_tester.prepare_config_and_inputs_for_common()
        _snake_case		:						List[str]         =  True

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

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

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

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

              _snake_case		:						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 					UpperCAmelCase_					(		self		)		->    Optional[int]:






        """simple docstring"""





        _snake_case		:						List[str]         =  SwinaSRImageProcessor()
        _snake_case		:						int         =  SwinaSRForImageSuperResolution.from_pretrained('''caidas/swin2SR-classical-sr-x2-64'''		).to(lowercase__		)

        _snake_case		:						Any         =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
        _snake_case		:						Any         =  processor(images=lowercase__  ,  return_tensors='''pt'''		).to(lowercase__		)

        # forward pass
        with torch.no_grad():
              _snake_case		:						List[str]         =  model(**lowercase__		)

        # verify the logits
        _snake_case		:						Tuple         =  torch.Size([1, 3, 976, 1_296]		)
        self.assertEqual(outputs.reconstruction.shape  ,  lowercase__		)
        _snake_case		:						List[Any]         =  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		)		)









'''simple docstring'''

def  _a     (				lowerCAmelCase_ = 4_000_000						):





      """simple docstring"""



      _snake_case		:						Optional[int]         =  1
      _snake_case		:						Tuple         =  2
      _snake_case		:						Optional[Any]         =  0
      while j <= n:
            if j % 2 == 0:
                  total += j
            _snake_case  ,				_snake_case		:						str         =  j, i + j

      return total


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


