code: 
  
  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 		__magic_name__    :
  
     '''simple docstring'''
  
  
  
  
     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,					)							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=parent
       a__						=batch_size
       a__						=image_size
       a__						=patch_size
       a__						=num_channels
       a__						=embed_dim
       a__						=depths
       a__						=num_heads
       a__						=window_size
       a__						=mlp_ratio
       a__						=qkv_bias
       a__						=hidden_dropout_prob
       a__						=attention_probs_dropout_prob
       a__						=drop_path_rate
       a__						=hidden_act
       a__						=use_absolute_embeddings
       a__						=patch_norm
       a__						=layer_norm_eps
       a__						=initializer_range
       a__						=is_training
       a__						=scope
       a__						=use_labels
       a__						=upscale
  
       # here we set some attributes to make tests pass
       a__						=len(lowercase_ )
       a__						=embed_dim
       a__						=(image_size // patch_size) ** 2
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )
  
       a__						=None
       if self.use_labels:
         a__						=ids_tensor([self.batch_size],					self.type_sequence_label_size )
  
       a__						=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_ )							->					List[str]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=SwinaSRModel(config=lowercase_ )
       model.to(lowercase_ )
       model.eval()
       a__						=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_ )							->					List[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=SwinaSRForImageSuperResolution(lowercase_ )
       model.to(lowercase_ )
       model.eval()
       a__						=model(lowercase_ )
  
       a__						=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 )							->					List[str]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.prepare_config_and_inputs()
       a__,   a__,   a__						=config_and_inputs
       a__						={'''pixel_values''': pixel_values}
       return config, inputs_dict
  
  
  
  
  
  
  
  @require_torch
  class 		__magic_name__    (							lowerCamelCase__	, lowerCamelCase__	, unittest.TestCase							):
  
     '''simple docstring'''
  
  
  
  
     lowerCamelCase__				:			Dict												=     (SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
     lowerCamelCase__				:			Optional[int]												=     {'feature-extraction': SwinaSRModel} if is_torch_available() else {}
  
     lowerCamelCase__				:			str												=     False
     lowerCamelCase__				:			Any												=     False
     lowerCamelCase__				:			Dict												=     False
     lowerCamelCase__				:			int												=     False
     lowerCamelCase__				:			Any												=     False
  
  
  
     def 				_UpperCAmelCase				(       self )							->					List[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=SwinaSRModelTester(self )
       a__						=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 )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=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 )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       pass
  
  
  
     @unittest.skip(reason='''Swin2SR does not use inputs_embeds''' )
     def 				_UpperCAmelCase				(       self )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       pass
  
  
  
     @unittest.skip(reason='''Swin2SR does not support training yet''' )
     def 				_UpperCAmelCase				(       self )							->					List[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 )							->					Union[str, Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__,   a__						=self.model_tester.prepare_config_and_inputs_for_common()
  
       for model_class in self.all_model_classes:
         a__						=model_class(lowercase_ )
         self.assertIsInstance(model.get_input_embeddings(),					(nn.Module) )
         a__						=model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(lowercase_,					nn.Linear ) )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					str:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__,   a__						=self.model_tester.prepare_config_and_inputs_for_common()
  
       for model_class in self.all_model_classes:
         a__						=model_class(lowercase_ )
         a__						=inspect.signature(model.forward )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         a__						=[*signature.parameters.keys()]
  
         a__						=['''pixel_values''']
         self.assertListEqual(arg_names[:1],					lowercase_ )
  
  
  
     @slow
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         a__						=SwinaSRModel.from_pretrained(lowercase_ )
         self.assertIsNotNone(lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__,   a__						=self.model_tester.prepare_config_and_inputs_for_common()
  
       a__						=_config_zero_init(lowercase_ )
       for model_class in self.all_model_classes:
         a__						=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 )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__,   a__						=self.model_tester.prepare_config_and_inputs_for_common()
       a__						=True
  
       for model_class in self.all_model_classes:
         a__						=True
         a__						=False
         a__						=True
         a__						=model_class(lowercase_ )
         model.to(lowercase_ )
         model.eval()
         with torch.no_grad():
           a__						=model(**self._prepare_for_class(lowercase_,					lowercase_ ) )
         a__						=outputs.attentions
         a__						=len(self.model_tester.depths )
         self.assertEqual(len(lowercase_ ),					lowercase_ )
  
         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         a__						=True
         a__						=config.window_size**2
         a__						=model_class(lowercase_ )
         model.to(lowercase_ )
         model.eval()
         with torch.no_grad():
           a__						=model(**self._prepare_for_class(lowercase_,					lowercase_ ) )
         a__						=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],					)
         a__						=len(lowercase_ )
  
         # Check attention is always last and order is fine
         a__						=True
         a__						=True
         a__						=model_class(lowercase_ )
         model.to(lowercase_ )
         model.eval()
         with torch.no_grad():
           a__						=model(**self._prepare_for_class(lowercase_,					lowercase_ ) )
  
         self.assertEqual(out_len + 1,					len(lowercase_ ) )
  
         a__						=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 		__magic_name__    (							unittest.TestCase							):
  
     '''simple docstring'''
  
  
  
  
     def 				_UpperCAmelCase				(       self )							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=SwinaSRImageProcessor()
       a__						=SwinaSRForImageSuperResolution.from_pretrained('''caidas/swin2SR-classical-sr-x2-64''' ).to(lowercase_ )
  
       a__						=Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
       a__						=processor(images=lowercase_,					return_tensors='''pt''' ).to(lowercase_ )
  
       # forward pass
       with torch.no_grad():
         a__						=model(**lowercase_ )
  
       # verify the logits
       a__						=torch.Size([1, 3, 976, 1296] )
       self.assertEqual(outputs.reconstruction.shape,					lowercase_ )
       a__						=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 ) )
  
style_context: 
  
  from dataclasses import dataclass
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  from PIL import Image
  
  from ...utils import BaseOutput, is_torch_available, is_transformers_available
  
  
  
  
  
  
  
  @dataclass
  # Copied from diffusers.pipelines.stable_diffusion.__init__.StableDiffusionPipelineOutput with Stable->Alt
  class 		__magic_name__    (							lowerCamelCase__							):
  
     '''simple docstring'''
  
  
  
  
     lowerCamelCase__				:			Union[List[PIL.Image.Image], np.ndarray]
     lowerCamelCase__				:			Optional[List[bool]]
  
  
  if is_transformers_available() and is_torch_available():
         from .modeling_roberta_series import RobertaSeriesModelWithTransformation
         from .pipeline_alt_diffusion import AltDiffusionPipeline
         from .pipeline_alt_diffusion_imgaimg import AltDiffusionImgaImgPipeline
  