




from typing import List

from packaging import version
from sklearn.metrics import fa_score

import datasets
from datasets.config import PY_VERSION


if PY_VERSION < version.parse('3.8'):
							import importlib_metadata
else:
							import importlib.metadata as importlib_metadata


# TODO(Patrick/Anton)
UpperCamelCase__              =						'\\n'

UpperCamelCase__              =						'\\n    XTREME-S is a benchmark to evaluate universal cross-lingual speech representations in many languages.\n    XTREME-S covers four task families: speech recognition, classification, speech-to-text translation and retrieval.\n'

UpperCamelCase__              =						'\nCompute XTREME-S evaluation metric associated to each XTREME-S dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    bleu_kwargs: optional dict of keywords to be passed when computing \'bleu\'.\n        Keywords include Dict can be one of \'smooth_method\', \'smooth_value\', \'force\', \'lowercase\',\n        \'tokenize\', \'use_effective_order\'.\n    wer_kwargs: optional dict of keywords to be passed when computing \'wer\' and \'cer\'.\n        Keywords include \'concatenate_texts\'.\nReturns: depending on the XTREME-S task, one or several of:\n    "accuracy": Accuracy - for \'fleurs-lang_id\', \'minds14\'\n    "f1": F1 score - for \'minds14\'\n    "wer": Word error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "cer": Character error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "bleu": BLEU score according to the `sacrebleu` metric - for \'covost2\'\nExamples:\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'mls\')  # \'mls\', \'voxpopuli\', \'fleurs-asr\' or \'babel\'\n    >>> references = ["it is sunny here", "paper and pen are essentials"]\n    >>> predictions = ["it\'s sunny", "paper pen are essential"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'wer\': 0.56, \'cer\': 0.27}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'covost2\')\n    >>> references = ["bonjour paris", "il est necessaire de faire du sport de temps en temp"]\n    >>> predictions = ["bonjour paris", "il est important de faire du sport souvent"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'bleu\': 31.65}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'fleurs-lang_id\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'accuracy\': 0.6}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'minds14\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'f1\': 0.58, \'accuracy\': 0.6}\n'

UpperCamelCase__              =						['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
UpperCamelCase__              =						''

try:
							from jiwer import transforms as tr

							UpperCamelCase__              =						True
except ImportError:
							UpperCamelCase__              =						False

if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):


							class 				__SCREAMING_SNAKE_CASE							(		tr.AbstractTransform  ):

												def __init__(				self ,       __lowercase = " "					):







													'''simple docstring'''




													lowerCamelCase_							:		str							   =							sentence_delimiter

												def 	lowercase_							(				self ,       __lowercase					):







													'''simple docstring'''




													return list(__lowercase					)





												def 	lowercase_							(				self ,       __lowercase					):







													'''simple docstring'''




													lowerCamelCase_							:		Optional[int]							   =							[]
													for sent_idx, sentence in enumerate(__lowercase					):
														chars.extend(self.process_string(__lowercase					)					)
														if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(__lowercase					) - 1:
															chars.append(self.sentence_delimiter					)
													return chars
							UpperCamelCase__              =						tr.Compose(
							    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
							)
elif _jiwer_available:
							UpperCamelCase__              =						tr.Compose(
							    [
							        tr.RemoveMultipleSpaces(),
							        tr.Strip(),
							        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
							        tr.ReduceToListOfListOfChars(),
							    ]
							)
else:
							UpperCamelCase__              =						None






def 					snake_case					(							A						,   A			)							->							Optional[Any]:




	'''simple docstring'''


	return float((preds == labels).mean()			)






def 					snake_case					(							A						,   A			)							->							Any:




	'''simple docstring'''


	return {
	    "f1": float(fa_score(y_true=A						,   y_pred=A						,   average='macro'			)			),
	    "accuracy": simple_accuracy(A						,   A			),
	}






def 					snake_case					(							A						,   A						,   A="exp"						,   A=None						,   A=False						,   A=False						,   A=None						,   A=False						,   )							->							int:




	'''simple docstring'''


	lowerCamelCase_							:		Optional[int]							   =							[[label] for label in labels]
	lowerCamelCase_							:		Any							   =							list(A			)
	try:
		import sacrebleu as scb
	except ImportError:
		raise ValueError(
		    'sacrebleu has to be installed in order to apply the bleu metric for covost2.'
		    'You can install it via `pip install sacrebleu`.'			)

	if version.parse(scb.__version__			) < version.parse('1.4.12'			):
		raise ImportWarning(
		    'To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n'
		    'You can install it with `pip install "sacrebleu>=1.4.12"`.'			)

	lowerCamelCase_							:		str							   =							len(labels[0]			)
	if any(len(A			) != references_per_prediction for refs in labels			):
		raise ValueError('Sacrebleu requires the same number of references for each prediction'			)
	lowerCamelCase_							:		Tuple							   =							[[refs[i] for refs in labels] for i in range(A			)]
	lowerCamelCase_							:		Optional[Any]							   =							scb.corpus_bleu(
	    A						,   A						,   smooth_method=A						,   smooth_value=A						,   force=A						,   lowercase=A						,   use_effective_order=A						,   **({'tokenize': tokenize} if tokenize else {})						,   )
	return {"bleu": output.score}






def 					snake_case					(							A						,   A						,   A						,   A			)							->							Optional[int]:




	'''simple docstring'''


	try:
		from jiwer import compute_measures
	except ImportError:
		raise ValueError(
		    f"jiwer has to be installed in order to apply the wer metric for {config_name}."
		    'You can install it via `pip install jiwer`.'			)

	if concatenate_texts:
		lowerCamelCase_							:		Optional[int]							   =							compute_measures(A						,   A			)['wer']

		lowerCamelCase_							:		Tuple							   =							compute_measures(A						,   A						,   truth_transform=A						,   hypothesis_transform=A			)['wer']
		return {"wer": wer, "cer": cer}
	else:

		def compute_score(A						,   A						,   A="wer"			):
			lowerCamelCase_							:		Union[str, Any]							   =							0
			lowerCamelCase_							:		Optional[int]							   =							0
			for prediction, reference in zip(A						,   A			):
				if score_type == "wer":
					lowerCamelCase_							:		List[str]							   =							compute_measures(A						,   A			)
				elif score_type == "cer":
					lowerCamelCase_							:		Union[str, Any]							   =							compute_measures(
					    A						,   A						,   truth_transform=A						,   hypothesis_transform=A			)
				incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
				total += measures["substitutions"] + measures["deletions"] + measures["hits"]
			return incorrect / total

		return {"wer": compute_score(A						,   A						,   'wer'			), "cer": compute_score(A						,   A						,   'cer'			)}



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,     _KWARGS_DESCRIPTION  )
class 				__SCREAMING_SNAKE_CASE							(		datasets.Metric  ):

					def 	lowercase_							(				self					):







						'''simple docstring'''




						if self.config_name not in _CONFIG_NAMES:
							raise KeyError(f"You should supply a configuration name selected in {_CONFIG_NAMES}"					)

						lowerCamelCase_							:		List[str]							   =							'int64' if self.config_name in ['fleurs-lang_id', 'minds14'] else 'string'

						return datasets.MetricInfo(
						    description=_DESCRIPTION ,       citation=_CITATION ,       inputs_description=_KWARGS_DESCRIPTION ,       features=datasets.Features(
						        {'predictions': datasets.Value(__lowercase					), 'references': datasets.Value(__lowercase					)}					) ,       codebase_urls=[] ,       reference_urls=[] ,       format='numpy' ,       )





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







						'''simple docstring'''




						lowerCamelCase_							:		Optional[int]							   =							bleu_kwargs if bleu_kwargs is not None else {}
						lowerCamelCase_							:		List[Any]							   =							wer_kwargs if wer_kwargs is not None else {}

						if self.config_name == "fleurs-lang_id":
							return {"accuracy": simple_accuracy(__lowercase ,       __lowercase					)}
						elif self.config_name == "minds14":
							return fa_and_simple_accuracy(__lowercase ,       __lowercase					)
						elif self.config_name == "covost2":
							lowerCamelCase_							:		Tuple							   =							bleu_kwargs.pop('smooth_method' ,       'exp'					)
							lowerCamelCase_							:		Optional[Any]							   =							bleu_kwargs.pop('smooth_value' ,       __lowercase					)
							lowerCamelCase_							:		Tuple							   =							bleu_kwargs.pop('force' ,       __lowercase					)
							lowerCamelCase_							:		Optional[int]							   =							bleu_kwargs.pop('lowercase' ,       __lowercase					)
							lowerCamelCase_							:		Dict							   =							bleu_kwargs.pop('tokenize' ,       __lowercase					)
							lowerCamelCase_							:		List[str]							   =							bleu_kwargs.pop('use_effective_order' ,       __lowercase					)
							return bleu(
							    preds=__lowercase ,       labels=__lowercase ,       smooth_method=__lowercase ,       smooth_value=__lowercase ,       force=__lowercase ,       lowercase=__lowercase ,       tokenize=__lowercase ,       use_effective_order=__lowercase ,       )
						elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
							lowerCamelCase_							:		Optional[Any]							   =							wer_kwargs.pop('concatenate_texts' ,       __lowercase					)
							return wer_and_cer(__lowercase ,       __lowercase ,       __lowercase ,       self.config_name					)
						else:
							raise KeyError(f"You should supply a configuration name selected in {_CONFIG_NAMES}"					)






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