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







   """simple docstring"""

   def __init__(			self			: Tuple,   UpperCamelCase__			: List[str],   UpperCamelCase__			: Union[str, Any]=13,   UpperCamelCase__			: int=32,   UpperCamelCase__			: Optional[Any]=1,   UpperCamelCase__			: Dict=3,   UpperCamelCase__			: Any=16,   UpperCamelCase__			: Any=[1, 2, 1],   UpperCamelCase__			: Optional[Any]=[2, 2, 4],   UpperCamelCase__			: List[Any]=2,   UpperCamelCase__			: Tuple=2.0,   UpperCamelCase__			: List[str]=True,   UpperCamelCase__			: List[str]=0.0,   UpperCamelCase__			: str=0.0,   UpperCamelCase__			: Optional[int]=0.1,   UpperCamelCase__			: Union[str, Any]="gelu",   UpperCamelCase__			: Tuple=False,   UpperCamelCase__			: int=True,   UpperCamelCase__			: int=0.02,   UpperCamelCase__			: Tuple=1e-5,   UpperCamelCase__			: Optional[int]=True,   UpperCamelCase__			: Union[str, Any]=None,   UpperCamelCase__			: int=False,   UpperCamelCase__			: Union[str, Any]=2,   )     -> str:
        _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(UpperCamelCase__    )
        _A								=     embed_dim
        _A								=     (image_size // patch_size) ** 2
   def   __UpperCAmelCase      (			self			: Optional[Any]    )     -> int:
        _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			: Dict    )     -> 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   __UpperCAmelCase      (			self			: List[str],   UpperCamelCase__			: List[str],   UpperCamelCase__			: Union[str, Any],   UpperCamelCase__			: str    )     -> List[str]:
        _A								=     SwinaSRModel(config=UpperCamelCase__    )
        model.to(UpperCamelCase__    )
        model.eval()
        _A								=     model(UpperCamelCase__    )

        self.parent.assertEqual(
            result.last_hidden_state.shape,   (self.batch_size, self.embed_dim, self.image_size, self.image_size)    )
   def   __UpperCAmelCase      (			self			: int,   UpperCamelCase__			: Tuple,   UpperCamelCase__			: Union[str, Any],   UpperCamelCase__			: Optional[int]    )     -> Dict:
        _A								=     SwinaSRForImageSuperResolution(UpperCamelCase__    )
        model.to(UpperCamelCase__    )
        model.eval()
        _A								=     model(UpperCamelCase__    )

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







@require_torch
class lowercase_					(		_UpperCamelCase						,						_UpperCamelCase						,						unittest.TestCase ):







   """simple docstring"""

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

   __lowerCAmelCase    						=      False
   __lowerCAmelCase    						=      False
   __lowerCAmelCase    						=      False
   __lowerCAmelCase    						=      False
   __lowerCAmelCase    						=      False
   def   __UpperCAmelCase      (			self			: Dict    )     -> int:
        _A								=     SwinaSRModelTester(self    )
        _A								=     ConfigTester(self,   config_class=UpperCamelCase__,   embed_dim=37    )
   def   __UpperCAmelCase      (			self			: int    )     -> Dict:
        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			: str    )     -> Any:
        _A								=     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*UpperCamelCase__    )
   def   __UpperCAmelCase      (			self			: Any    )     -> Any:
        _A								=     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   __UpperCAmelCase      (			self			: int    )     -> Any:
        pass
   @unittest.skip(reason='Swin2SR does not use inputs_embeds'    )
   def   __UpperCAmelCase      (			self			: Tuple    )     -> Optional[int]:
        pass
   @unittest.skip(reason='Swin2SR does not support training yet'    )
   def   __UpperCAmelCase      (			self			: Union[str, Any]    )     -> Union[str, Any]:
        pass
   @unittest.skip(reason='Swin2SR does not support training yet'    )
   def   __UpperCAmelCase      (			self			: List[str]    )     -> Dict:
        pass
   def   __UpperCAmelCase      (			self			: Optional[Any]    )     -> Any:
        _A		,					_A								=     self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             _A								=     model_class(UpperCamelCase__    )
             self.assertIsInstance(model.get_input_embeddings(),   (nn.Module)    )
             _A								=     model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(UpperCamelCase__,   nn.Linear    )    )
   def   __UpperCAmelCase      (			self			: str    )     -> Optional[Any]:
        _A		,					_A								=     self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             _A								=     model_class(UpperCamelCase__    )
             _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],   UpperCamelCase__    )
   @slow
   def   __UpperCAmelCase      (			self			: Any    )     -> List[Any]:
        for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _A								=     SwinaSRModel.from_pretrained(UpperCamelCase__    )
             self.assertIsNotNone(UpperCamelCase__    )
   def   __UpperCAmelCase      (			self			: Optional[int]    )     -> str:
        _A		,					_A								=     self.model_tester.prepare_config_and_inputs_for_common()

        _A								=     _config_zero_init(UpperCamelCase__    )
        for model_class in self.all_model_classes:
             _A								=     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   __UpperCAmelCase      (			self			: Union[str, Any]    )     -> Dict:
        _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(UpperCamelCase__    )
             model.to(UpperCamelCase__    )
             model.eval()
             with torch.no_grad():
                  _A								=     model(**self._prepare_for_class(UpperCamelCase__,   UpperCamelCase__    )    )
             _A								=     outputs.attentions
             _A								=     len(self.model_tester.depths    )
             self.assertEqual(len(UpperCamelCase__    ),   UpperCamelCase__    )

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

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

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

             _A								=     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 lowercase_					(		unittest.TestCase ):







   """simple docstring"""

   def   __UpperCAmelCase      (			self			: Any    )     -> Optional[Any]:
        _A								=     SwinaSRImageProcessor()
        _A								=     SwinaSRForImageSuperResolution.from_pretrained('caidas/swin2SR-classical-sr-x2-64'    ).to(UpperCamelCase__    )

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

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

        # verify the logits
        _A								=     torch.Size([1, 3, 9_76, 12_96]    )
        self.assertEqual(outputs.reconstruction.shape,   UpperCamelCase__    )
        _A								=     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(UpperCamelCase__    )
        self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3],   UpperCamelCase__,   atol=1e-4    )    )




'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


_UpperCAmelCase						:    Optional[Any]     					=					{
    '''configuration_unispeech_sat''': ['''UNISPEECH_SAT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''UniSpeechSatConfig'''],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCAmelCase						:    Dict     					=					[
       '''UNISPEECH_SAT_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''UniSpeechSatForAudioFrameClassification''',
       '''UniSpeechSatForCTC''',
       '''UniSpeechSatForPreTraining''',
       '''UniSpeechSatForSequenceClassification''',
       '''UniSpeechSatForXVector''',
       '''UniSpeechSatModel''',
       '''UniSpeechSatPreTrainedModel''',
   ]

if TYPE_CHECKING:
   from .configuration_unispeech_sat import UNISPEECH_SAT_PRETRAINED_CONFIG_ARCHIVE_MAP, UniSpeechSatConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_unispeech_sat import (
          UNISPEECH_SAT_PRETRAINED_MODEL_ARCHIVE_LIST,
          UniSpeechSatForAudioFrameClassification,
          UniSpeechSatForCTC,
          UniSpeechSatForPreTraining,
          UniSpeechSatForSequenceClassification,
          UniSpeechSatForXVector,
          UniSpeechSatModel,
          UniSpeechSatPreTrainedModel,
      )

else:
   import sys

   _UpperCAmelCase						:    int     					=					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



