
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:

						def __init__(					self		:			Tuple	,						_lowerCamelCase		:			Union[str, Any]	,						_lowerCamelCase		:			str=13	,						_lowerCamelCase		:			Tuple=32	,						_lowerCamelCase		:			List[Any]=1	,						_lowerCamelCase		:			Any=3	,						_lowerCamelCase		:			int=16	,						_lowerCamelCase		:			Any=[1, 2, 1]	,						_lowerCamelCase		:			Union[str, Any]=[2, 2, 4]	,						_lowerCamelCase		:			Optional[int]=2	,						_lowerCamelCase		:			Tuple=2.0	,						_lowerCamelCase		:			Optional[Any]=True	,						_lowerCamelCase		:			str=0.0	,						_lowerCamelCase		:			List[str]=0.0	,						_lowerCamelCase		:			Dict=0.1	,						_lowerCamelCase		:			Optional[Any]="gelu"	,						_lowerCamelCase		:			Any=False	,						_lowerCamelCase		:			Optional[Any]=True	,						_lowerCamelCase		:			Optional[Any]=0.02	,						_lowerCamelCase		:			List[str]=1E-5	,						_lowerCamelCase		:			Optional[Any]=True	,						_lowerCamelCase		:			Dict=None	,						_lowerCamelCase		:			Dict=False	,						_lowerCamelCase		:			Dict=2	,						):
													_UpperCAmelCase  :			List[str]	       =		parent
													_UpperCAmelCase  :			Dict	       =		batch_size
													_UpperCAmelCase  :			Any	       =		image_size
													_UpperCAmelCase  :			Optional[int]	       =		patch_size
													_UpperCAmelCase  :			Union[str, Any]	       =		num_channels
													_UpperCAmelCase  :			List[str]	       =		embed_dim
													_UpperCAmelCase  :			Tuple	       =		depths
													_UpperCAmelCase  :			Tuple	       =		num_heads
													_UpperCAmelCase  :			Any	       =		window_size
													_UpperCAmelCase  :			str	       =		mlp_ratio
													_UpperCAmelCase  :			Any	       =		qkv_bias
													_UpperCAmelCase  :			Optional[int]	       =		hidden_dropout_prob
													_UpperCAmelCase  :			int	       =		attention_probs_dropout_prob
													_UpperCAmelCase  :			int	       =		drop_path_rate
													_UpperCAmelCase  :			Any	       =		hidden_act
													_UpperCAmelCase  :			str	       =		use_absolute_embeddings
													_UpperCAmelCase  :			Dict	       =		patch_norm
													_UpperCAmelCase  :			Tuple	       =		layer_norm_eps
													_UpperCAmelCase  :			Tuple	       =		initializer_range
													_UpperCAmelCase  :			str	       =		is_training
													_UpperCAmelCase  :			Optional[Any]	       =		scope
													_UpperCAmelCase  :			Optional[int]	       =		use_labels
													_UpperCAmelCase  :			Dict	       =		upscale

													# here we set some attributes to make tests pass
													_UpperCAmelCase  :			int	       =		len(A__			)
													_UpperCAmelCase  :			Any	       =		embed_dim
													_UpperCAmelCase  :			Tuple	       =		(image_size // patch_size) ** 2

						def 						a__ (					self		:			Tuple			):
													_UpperCAmelCase  :			Union[str, Any]	       =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

													_UpperCAmelCase  :			Optional[Any]	       =		self.get_config()

													return config, pixel_values, labels

						def 						a__ (					self		:			Union[str, Any]			):
													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 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			str	,						_lowerCamelCase		:			List[str]	,						_lowerCamelCase		:			List[Any]			):
													_UpperCAmelCase  :			int	       =		SwinaSRModel(config=A__			)
													model.to(A__			)
													model.eval()
													_UpperCAmelCase  :			Any	       =		model(A__			)

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

						def 						a__ (					self		:			int	,						_lowerCamelCase		:			List[str]	,						_lowerCamelCase		:			Optional[Any]	,						_lowerCamelCase		:			str			):
													_UpperCAmelCase  :			Optional[int]	       =		SwinaSRForImageSuperResolution(A__			)
													model.to(A__			)
													model.eval()
													_UpperCAmelCase  :			List[Any]	       =		model(A__			)

													_UpperCAmelCase  :			Union[str, Any]	       =		self.image_size * self.upscale
													self.parent.assertEqual(
													    result.reconstruction.shape	,						(self.batch_size, self.num_channels, expected_image_size, expected_image_size)			)






						def 						a__ (					self		:			Dict			):
													_UpperCAmelCase  :			Union[str, Any]	       =		self.prepare_config_and_inputs()
													_UpperCAmelCase       ,_UpperCAmelCase       ,_UpperCAmelCase  :			Dict	       =		config_and_inputs
													_UpperCAmelCase  :			Optional[Any]	       =		{"pixel_values": pixel_values}
													return config, inputs_dict







@require_torch
class    _UpperCamelCase(   __lowercase		,						__lowercase		,						unittest.TestCase				):
						__A:						str				   =      (SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
						__A:						Optional[Any]				   =      {"feature-extraction": SwinaSRModel} if is_torch_available() else {}

						__A:						Dict				   =      False
						__A:						Optional[int]				   =      False
						__A:						Optional[Any]				   =      False
						__A:						Dict				   =      False
						__A:						Tuple				   =      False

						def 						a__ (					self		:			str			):
													_UpperCAmelCase  :			Dict	       =		SwinaSRModelTester(self			)
													_UpperCAmelCase  :			Tuple	       =		ConfigTester(self	,						config_class=A__	,						embed_dim=37			)

						def 						a__ (					self		:			Optional[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 						a__ (					self		:			Union[str, Any]			):
													_UpperCAmelCase  :			Tuple	       =		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*A__			)

						def 						a__ (					self		:			Optional[int]			):
													_UpperCAmelCase  :			Optional[Any]	       =		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_super_resolution(*A__			)

						@unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0."			)
						def 						a__ (					self		:			List[str]			):
													pass

						@unittest.skip(reason="Swin2SR does not use inputs_embeds"			)
						def 						a__ (					self		:			Any			):
													pass

						@unittest.skip(reason="Swin2SR does not support training yet"			)
						def 						a__ (					self		:			int			):
													pass

						@unittest.skip(reason="Swin2SR does not support training yet"			)
						def 						a__ (					self		:			str			):
													pass

						def 						a__ (					self		:			Tuple			):
													_UpperCAmelCase       ,_UpperCAmelCase  :			Optional[int]	       =		self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				_UpperCAmelCase  :			List[Any]	       =		model_class(A__			)
																				self.assertIsInstance(model.get_input_embeddings()	,						(nn.Module)			)
																				_UpperCAmelCase  :			int	       =		model.get_output_embeddings()
																				self.assertTrue(x is None or isinstance(A__	,						nn.Linear			)			)

						def 						a__ (					self		:			List[str]			):
													_UpperCAmelCase       ,_UpperCAmelCase  :			Optional[Any]	       =		self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				_UpperCAmelCase  :			Optional[Any]	       =		model_class(A__			)
																				_UpperCAmelCase  :			Tuple	       =		inspect.signature(model.forward			)
																				# signature.parameters is an OrderedDict => so arg_names order is deterministic
																				_UpperCAmelCase  :			Any	       =		[*signature.parameters.keys()]

																				_UpperCAmelCase  :			Optional[Any]	       =		["pixel_values"]
																				self.assertListEqual(arg_names[:1]	,						A__			)

						@slow
						def 						a__ (					self		:			List[Any]			):
													for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				_UpperCAmelCase  :			str	       =		SwinaSRModel.from_pretrained(A__			)
																				self.assertIsNotNone(A__			)

						def 						a__ (					self		:			Union[str, Any]			):
													_UpperCAmelCase       ,_UpperCAmelCase  :			Union[str, Any]	       =		self.model_tester.prepare_config_and_inputs_for_common()

													_UpperCAmelCase  :			List[str]	       =		_config_zero_init(A__			)
													for model_class in self.all_model_classes:
																				_UpperCAmelCase  :			str	       =		model_class(config=A__			)
																				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 						a__ (					self		:			List[Any]			):
													_UpperCAmelCase       ,_UpperCAmelCase  :			Tuple	       =		self.model_tester.prepare_config_and_inputs_for_common()
													_UpperCAmelCase  :			Union[str, Any]	       =		True

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

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

																				self.assertListEqual(
																				    list(attentions[0].shape[-3:]			)	,						[self.model_tester.num_heads[0], window_size_squared, window_size_squared]	,						)
																				_UpperCAmelCase  :			int	       =		len(A__			)

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

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

																				_UpperCAmelCase  :			int	       =		outputs.attentions

																				self.assertEqual(len(A__			)	,						A__			)

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

						def 						a__ (					self		:			Tuple			):
													_UpperCAmelCase  :			Tuple	       =		SwinaSRImageProcessor()
													_UpperCAmelCase  :			Dict	       =		SwinaSRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64"			).to(A__			)

													_UpperCAmelCase  :			Optional[Any]	       =		Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
													_UpperCAmelCase  :			Optional[Any]	       =		processor(images=A__	,						return_tensors="pt"			).to(A__			)

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

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







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__A     						=      {'''configuration_hubert''': ['''HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''HubertConfig''']}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A     						=      [
     '''HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''HubertForCTC''',
     '''HubertForSequenceClassification''',
     '''HubertModel''',
     '''HubertPreTrainedModel''',
 ]


try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __A     						=      [
     '''TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''TFHubertForCTC''',
     '''TFHubertModel''',
     '''TFHubertPreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_hubert import HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, HubertConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_hubert import (
      HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      HubertForCTC,
      HubertForSequenceClassification,
      HubertModel,
      HubertPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_hubert import (
      TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFHubertForCTC,
      TFHubertModel,
      TFHubertPreTrainedModel,
  )


else:
 import sys

 __A     						=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

