






"""simple docstring"""
import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
      import torch


A_			: Tuple				=			random.Random()






def        lowerCamelCase_  (						_lowerCamelCase			,   _lowerCamelCase=1.0			,   _lowerCamelCase=None			,   _lowerCamelCase=None				):
 if rng is None:
  lowerCamelCase__     :			int     				=						global_rng

 lowerCamelCase__     :			Union[str, Any]     				=						[]
 for batch_idx in range(shape[0]				):
  values.append([]				)
  for _ in range(shape[1]				):
   values[-1].append(rng.random() * scale				)

 return values



@require_torch
class 		a_      (	unittest.TestCase ):







      '''simple docstring'''

      def __init__(self,     lowerCamelCase_,     lowerCamelCase_=7,     lowerCamelCase_=4_0_0,     lowerCamelCase_=2_0_0_0,     lowerCamelCase_=1,     lowerCamelCase_=0.0,     lowerCamelCase_=2_4_0_0_0,     lowerCamelCase_=True,     ):

       '''simple docstring'''



       lowerCamelCase__     :			Optional[Any]     				=						parent
       lowerCamelCase__     :			Optional[Any]     				=						batch_size
       lowerCamelCase__     :			Tuple     				=						min_seq_length
       lowerCamelCase__     :			int     				=						max_seq_length
       lowerCamelCase__     :			Dict     				=						(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
       lowerCamelCase__     :			Dict     				=						feature_size
       lowerCamelCase__     :			Optional[int]     				=						padding_value
       lowerCamelCase__     :			Any     				=						sampling_rate
       lowerCamelCase__     :			Union[str, Any]     				=						return_attention_mask




      def 			a__							(self					):

       '''simple docstring'''



       return {
           "feature_size": self.feature_size,
           "padding_value": self.padding_value,
           "sampling_rate": self.sampling_rate,
           "return_attention_mask": self.return_attention_mask,
       }





      def 			a__							(self,     lowerCamelCase_=False,     lowerCamelCase_=False					):

       '''simple docstring'''



       def _flatten(lowerCamelCase_					):
        return list(itertools.chain(*lowerCamelCase_					)					)

       if equal_length:
        lowerCamelCase__     :			str     				=						floats_list((self.batch_size, self.max_seq_length)					)
       else:
        # make sure that inputs increase in size
        lowerCamelCase__     :			Tuple     				=						[
            _flatten(floats_list((x, self.feature_size)					)					)
            for x in range(self.min_seq_length,     self.max_seq_length,     self.seq_length_diff					)
        ]

       if numpify:
        lowerCamelCase__     :			int     				=						[np.asarray(lowerCamelCase_					) for x in audio_inputs]

       return audio_inputs



@require_torch
class 		a_      (	snake_case_  ,						unittest.TestCase ):







      '''simple docstring'''

      lowerCamelCase__       :				Dict =	EncodecFeatureExtractor




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Optional[int]     				=						EnCodecFeatureExtractionTester(self					)




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			str     				=						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
       # create three inputs of length 800, 1000, and 1200
       lowerCamelCase__     :			List[str]     				=						[floats_list((1, x)					)[0] for x in range(8_0_0,     1_4_0_0,     2_0_0					)]
       lowerCamelCase__     :			Optional[int]     				=						[np.asarray(lowerCamelCase_					) for audio_input in audio_inputs]

       # Test not batched input
       lowerCamelCase__     :			int     				=						feat_extract(audio_inputs[0],     return_tensors='np'					).input_values
       lowerCamelCase__     :			Dict     				=						feat_extract(np_audio_inputs[0],     return_tensors='np'					).input_values
       self.assertTrue(np.allclose(lowerCamelCase_,     lowerCamelCase_,     atol=1e-3					)					)

       # Test batched
       lowerCamelCase__     :			Optional[int]     				=						feat_extract(lowerCamelCase_,     padding=lowerCamelCase_,     return_tensors='np'					).input_values
       lowerCamelCase__     :			Optional[int]     				=						feat_extract(lowerCamelCase_,     padding=lowerCamelCase_,     return_tensors='np'					).input_values
       for enc_seq_a, enc_seq_a in zip(lowerCamelCase_,     lowerCamelCase_					):
        self.assertTrue(np.allclose(lowerCamelCase_,     lowerCamelCase_,     atol=1e-3					)					)




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Dict     				=						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
       lowerCamelCase__     :			List[str]     				=						np.random.rand(1_0_0					).astype(np.floataa					)
       lowerCamelCase__     :			Union[str, Any]     				=						np_audio_inputs.tolist()

       for inputs in [py_audio_inputs, np_audio_inputs]:
        lowerCamelCase__     :			Optional[Any]     				=						feature_extractor.pad([{'input_values': inputs}],     return_tensors='np'					)
        self.assertTrue(np_processed.input_values.dtype == np.floataa					)
        lowerCamelCase__     :			Tuple     				=						feature_extractor.pad([{'input_values': inputs}],     return_tensors='pt'					)
        self.assertTrue(pt_processed.input_values.dtype == torch.floataa					)




      def 			a__							(self,     lowerCamelCase_					):

       '''simple docstring'''



       from datasets import load_dataset

       lowerCamelCase__     :			Any     				=						load_dataset('hf-internal-testing/librispeech_asr_dummy',     'clean',     split='validation'					)
       # automatic decoding with librispeech
       lowerCamelCase__     :			Union[str, Any]     				=						ds.sort('id'					).select(range(lowerCamelCase_					)					)[:num_samples]['audio']

       return [x["array"] for x in audio_samples]




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Dict     				=						torch.tensor(
           [2.3_804e-03, 2.0_752e-03, 1.9_836e-03, 2.1_057e-03, 1.6_174e-03,
            3.0_518e-04, 9.1_553e-05, 3.3_569e-04, 9.7_656e-04, 1.8_311e-03,
            2.0_142e-03, 2.1_057e-03, 1.7_395e-03, 4.5_776e-04, -3.9_673e-04,
            4.5_776e-04, 1.0_071e-03, 9.1_553e-05, 4.8_828e-04, 1.1_597e-03,
            7.3_242e-04, 9.4_604e-04, 1.8_005e-03, 1.8_311e-03, 8.8_501e-04,
            4.2_725e-04, 4.8_828e-04, 7.3_242e-04, 1.0_986e-03, 2.1_057e-03]					)
       # fmt: on
       lowerCamelCase__     :			Dict     				=						self._load_datasamples(1					)
       lowerCamelCase__     :			Optional[Any]     				=						EncodecFeatureExtractor()
       lowerCamelCase__     :			List[Any]     				=						feature_extractor(lowerCamelCase_,     return_tensors='pt'					).input_values
       self.assertEquals(input_values.shape,     (1, 1, 9_3_6_8_0)					)
       self.assertTrue(torch.allclose(input_values[0, 0, :3_0],     lowerCamelCase_,     atol=1e-6					)					)




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Tuple     				=						torch.tensor(
           [2.3_804e-03, 2.0_752e-03, 1.9_836e-03, 2.1_057e-03, 1.6_174e-03,
            3.0_518e-04, 9.1_553e-05, 3.3_569e-04, 9.7_656e-04, 1.8_311e-03,
            2.0_142e-03, 2.1_057e-03, 1.7_395e-03, 4.5_776e-04, -3.9_673e-04,
            4.5_776e-04, 1.0_071e-03, 9.1_553e-05, 4.8_828e-04, 1.1_597e-03,
            7.3_242e-04, 9.4_604e-04, 1.8_005e-03, 1.8_311e-03, 8.8_501e-04,
            4.2_725e-04, 4.8_828e-04, 7.3_242e-04, 1.0_986e-03, 2.1_057e-03]					)
       # fmt: on
       lowerCamelCase__     :			Union[str, Any]     				=						self._load_datasamples(1					)
       lowerCamelCase__     :			Optional[int]     				=						[np.tile(input_audio[0][None],     reps=(2, 1)					)]
       input_audio[0][1] *= 0.5
       lowerCamelCase__     :			Optional[int]     				=						EncodecFeatureExtractor(feature_size=2					)
       lowerCamelCase__     :			str     				=						feature_extractor(lowerCamelCase_,     return_tensors='pt'					).input_values
       self.assertEquals(input_values.shape,     (1, 2, 9_3_6_8_0)					)
       self.assertTrue(torch.allclose(input_values[0, 0, :3_0],     lowerCamelCase_,     atol=1e-6					)					)
       self.assertTrue(torch.allclose(input_values[0, 1, :3_0],     EXPECTED_INPUT_VALUES * 0.5,     atol=1e-6					)					)





      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Dict     				=						self._load_datasamples(2					)
       # would be easier if the stride was like
       lowerCamelCase__     :			Union[str, Any]     				=						EncodecFeatureExtractor(feature_size=1,     chunk_length_s=1,     overlap=0.01					)

       # pad and trunc raise an error ?
       with self.assertRaisesRegex(
           lowerCamelCase_,     '^Both padding and truncation were set. Make sure you only set one.$',     ):
        lowerCamelCase__     :			Dict     				=						feature_extractor(
            lowerCamelCase_,     padding='max_length',     truncation=lowerCamelCase_,     return_tensors='pt'					).input_values

       # truncate to chunk
       lowerCamelCase__     :			str     				=						feature_extractor(lowerCamelCase_,     truncation=lowerCamelCase_,     return_tensors='pt'					).input_values
       self.assertEquals(truncated_outputs.shape,     (2, 1, 7_1_5_2_0)					)  # 2 chunks

       # force truncate to max_length
       lowerCamelCase__     :			Any     				=						feature_extractor(
           lowerCamelCase_,     truncation=lowerCamelCase_,     max_length=4_8_0_0_0,     return_tensors='pt'					).input_values
       self.assertEquals(truncated_outputs.shape,     (2, 1, 4_8_0_0_0)					)

       # pad to chunk
       lowerCamelCase__     :			Optional[Any]     				=						feature_extractor(lowerCamelCase_,     padding=lowerCamelCase_,     return_tensors='pt'					).input_values
       self.assertEquals(padded_outputs.shape,     (2, 1, 9_5_2_8_0)					)

       # pad to chunk
       lowerCamelCase__     :			List[str]     				=						feature_extractor(lowerCamelCase_,     return_tensors='pt'					).input_values
       self.assertEquals(truncated_outputs.shape,     (2, 1, 9_5_2_8_0)					)

       # force pad to max length
       lowerCamelCase__     :			str     				=						feature_extractor(
           lowerCamelCase_,     padding='max_length',     max_length=1_0_0_0_0_0,     return_tensors='pt'					).input_values
       self.assertEquals(truncated_outputs.shape,     (2, 1, 1_0_0_0_0_0)					)

       # force no pad
       with self.assertRaisesRegex(
           lowerCamelCase_,     '^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$',     ):
        lowerCamelCase__     :			Any     				=						feature_extractor(lowerCamelCase_,     padding=lowerCamelCase_,     return_tensors='pt'					).input_values

       lowerCamelCase__     :			List[str]     				=						feature_extractor(input_audio[0],     padding=lowerCamelCase_,     return_tensors='pt'					).input_values
       self.assertEquals(truncated_outputs.shape,     (1, 1, 9_3_6_8_0)					)

       # no pad if no chunk_length_s
       lowerCamelCase__     :			Optional[int]     				=						None
       with self.assertRaisesRegex(
           lowerCamelCase_,     '^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$',     ):
        lowerCamelCase__     :			List[Any]     				=						feature_extractor(lowerCamelCase_,     padding=lowerCamelCase_,     return_tensors='pt'					).input_values

       lowerCamelCase__     :			Any     				=						feature_extractor(input_audio[0],     padding=lowerCamelCase_,     return_tensors='pt'					).input_values
       self.assertEquals(truncated_outputs.shape,     (1, 1, 9_3_6_8_0)					)

       # no pad if no overlap
       lowerCamelCase__     :			Any     				=						2
       lowerCamelCase__     :			Optional[int]     				=						None
       with self.assertRaisesRegex(
           lowerCamelCase_,     '^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$',     ):
        lowerCamelCase__     :			Optional[int]     				=						feature_extractor(lowerCamelCase_,     padding=lowerCamelCase_,     return_tensors='pt'					).input_values

       lowerCamelCase__     :			List[str]     				=						feature_extractor(input_audio[0],     padding=lowerCamelCase_,     return_tensors='pt'					).input_values
       self.assertEquals(truncated_outputs.shape,     (1, 1, 9_3_6_8_0)					)







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							:

					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 ,       ):







						'''simple docstring'''




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

						# here we set some attributes to make tests pass
						lowerCamelCase_							:		int							   =							len(__lowercase					)
						lowerCamelCase_							:		Optional[int]							   =							embed_dim
						lowerCamelCase_							:		Tuple							   =							(image_size // patch_size) ** 2

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		int							   =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

						lowerCamelCase_							:		List[Any]							   =							None
						if self.use_labels:
							lowerCamelCase_							:		Dict							   =							ids_tensor([self.batch_size] ,       self.type_sequence_label_size					)

						lowerCamelCase_							:		int							   =							self.get_config()

						return config, pixel_values, labels

					def 	lowercase_							(				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 	lowercase_							(				self ,       __lowercase ,       __lowercase ,       __lowercase					):







						'''simple docstring'''




						lowerCamelCase_							:		Any							   =							SwinaSRModel(config=__lowercase					)
						model.to(__lowercase					)
						model.eval()
						lowerCamelCase_							:		int							   =							model(__lowercase					)

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

					def 	lowercase_							(				self ,       __lowercase ,       __lowercase ,       __lowercase					):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[Any]							   =							SwinaSRForImageSuperResolution(__lowercase					)
						model.to(__lowercase					)
						model.eval()
						lowerCamelCase_							:		Any							   =							model(__lowercase					)

						lowerCamelCase_							:		int							   =							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					):







						'''simple docstring'''




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


@require_torch
class 				__SCREAMING_SNAKE_CASE							(		lowerCamelCase   ,     lowerCamelCase   ,     unittest.TestCase  ):
					_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 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Tuple							   =							SwinaSRModelTester(self					)
						lowerCamelCase_							:		Optional[Any]							   =							ConfigTester(self ,       config_class=__lowercase ,       embed_dim=37					)

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







						'''simple docstring'''




						lowerCamelCase_							:		Optional[Any]							   =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__lowercase					)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		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 	lowercase_							(				self					):







						'''simple docstring'''




						pass

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







						'''simple docstring'''




						pass

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







						'''simple docstring'''




						pass

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







						'''simple docstring'''




						pass

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_   ,			lowerCamelCase_							:		Dict							   =							self.model_tester.prepare_config_and_inputs_for_common()

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

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_   ,			lowerCamelCase_							:		Optional[int]							   =							self.model_tester.prepare_config_and_inputs_for_common()

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

							lowerCamelCase_							:		Tuple							   =							['pixel_values']
							self.assertListEqual(arg_names[:1] ,       __lowercase					)

					@slow
					def 	lowercase_							(				self					):







						'''simple docstring'''




						for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							lowerCamelCase_							:		Tuple							   =							SwinaSRModel.from_pretrained(__lowercase					)
							self.assertIsNotNone(__lowercase					)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_   ,			lowerCamelCase_							:		Union[str, Any]							   =							self.model_tester.prepare_config_and_inputs_for_common()

						lowerCamelCase_							:		Optional[Any]							   =							_config_zero_init(__lowercase					)
						for model_class in self.all_model_classes:
							lowerCamelCase_							:		List[str]							   =							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 	lowercase_							(				self					):







						'''simple docstring'''




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

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

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

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

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

							lowerCamelCase_							:		str							   =							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  ):

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Union[str, Any]							   =							SwinaSRImageProcessor()
						lowerCamelCase_							:		Optional[int]							   =							SwinaSRForImageSuperResolution.from_pretrained('caidas/swin2SR-classical-sr-x2-64'					).to(__lowercase					)

						lowerCamelCase_							:		int							   =							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
						lowerCamelCase_							:		Optional[int]							   =							processor(images=__lowercase ,       return_tensors='pt'					).to(__lowercase					)

						# forward pass
						with torch.no_grad():
							lowerCamelCase_							:		Optional[int]							   =							model(**__lowercase					)

						# verify the logits
						lowerCamelCase_							:		Dict							   =							torch.Size([1, 3, 976, 1_296]					)
						self.assertEqual(outputs.reconstruction.shape ,       __lowercase					)
						lowerCamelCase_							:		Union[str, Any]							   =							torch.tensor(
						    [[0.54_58, 0.55_46, 0.56_38], [0.55_26, 0.55_65, 0.56_51], [0.53_96, 0.54_26, 0.56_21]]					).to(__lowercase					)
						self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3] ,       __lowercase ,       atol=1E-4					)					)
