





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






       '''simple docstring'''


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

            # here we set some attributes to make tests pass
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							len(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE				:		List[str]  			=							embed_dim
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							(image_size // patch_size) ** 2




       def 			UpperCamelCase_	(					self							)	->   List[str]:
            _SCREAMING_SNAKE_CASE				:		int  			=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

            _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							None
            if self.use_labels:
                 _SCREAMING_SNAKE_CASE				:		str  			=							ids_tensor([self.batch_size]			,  self.type_sequence_label_size							)

            _SCREAMING_SNAKE_CASE				:		Dict  			=							self.get_config()

            return config, pixel_values, labels




       def 			UpperCamelCase_	(					self							)	->   Optional[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 			UpperCamelCase_	(					self			,  __lowerCamelCase			,  __lowerCamelCase			,  __lowerCamelCase							)	->   Optional[int]:
            _SCREAMING_SNAKE_CASE				:		Any  			=							SwinaSRModel(config=__lowerCamelCase							)
            model.to(__lowerCamelCase							)
            model.eval()
            _SCREAMING_SNAKE_CASE				:		str  			=							model(__lowerCamelCase							)

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




       def 			UpperCamelCase_	(					self			,  __lowerCamelCase			,  __lowerCamelCase			,  __lowerCamelCase							)	->   Optional[int]:
            _SCREAMING_SNAKE_CASE				:		List[Any]  			=							SwinaSRForImageSuperResolution(__lowerCamelCase							)
            model.to(__lowerCamelCase							)
            model.eval()
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							model(__lowerCamelCase							)

            _SCREAMING_SNAKE_CASE				:		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 			UpperCamelCase_	(					self							)	->   List[Any]:
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							self.prepare_config_and_inputs()
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		List[str]  			=							config_and_inputs
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							{"pixel_values": pixel_values}
            return config, inputs_dict





@require_torch
class 	lowerCAmelCase__(       __lowercase     ,   __lowercase     ,   unittest.TestCase			):






       '''simple docstring'''


       __snake_case       	=			(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
       __snake_case       	=			{'feature-extraction': SwinaSRModel} if is_torch_available() else {}

       __snake_case       	=			False
       __snake_case       	=			False
       __snake_case       	=			False
       __snake_case       	=			False
       __snake_case       	=			False




       def 			UpperCamelCase_	(					self							)	->   List[Any]:
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							SwinaSRModelTester(self							)
            _SCREAMING_SNAKE_CASE				:		str  			=							ConfigTester(self			,  config_class=__lowerCamelCase			,  embed_dim=3_7							)




       def 			UpperCamelCase_	(					self							)	->   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 			UpperCamelCase_	(					self							)	->   int:
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__lowerCamelCase							)




       def 			UpperCamelCase_	(					self							)	->   Optional[Any]:
            _SCREAMING_SNAKE_CASE				:		Any  			=							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_super_resolution(*__lowerCamelCase							)




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




       @unittest.skip(reason="Swin2SR does not use inputs_embeds"							)
       def 			UpperCamelCase_	(					self							)	->   List[str]:
            pass




       @unittest.skip(reason="Swin2SR does not support training yet"							)
       def 			UpperCamelCase_	(					self							)	->   Union[str, Any]:
            pass




       @unittest.skip(reason="Swin2SR does not support training yet"							)
       def 			UpperCamelCase_	(					self							)	->   Union[str, Any]:
            pass




       def 			UpperCamelCase_	(					self							)	->   Union[str, Any]:
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		str  			=							self.model_tester.prepare_config_and_inputs_for_common()

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




       def 			UpperCamelCase_	(					self							)	->   Optional[int]:
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		Optional[int]  			=							self.model_tester.prepare_config_and_inputs_for_common()

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

                 _SCREAMING_SNAKE_CASE				:		Tuple  			=							["pixel_values"]
                 self.assertListEqual(arg_names[:1]			,  __lowerCamelCase							)




       @slow
       def 			UpperCamelCase_	(					self							)	->   List[Any]:
            for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _SCREAMING_SNAKE_CASE				:		str  			=							SwinaSRModel.from_pretrained(__lowerCamelCase							)
                 self.assertIsNotNone(__lowerCamelCase							)




       def 			UpperCamelCase_	(					self							)	->   Union[str, Any]:
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		str  			=							self.model_tester.prepare_config_and_inputs_for_common()

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

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

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

                 self.assertListEqual(
                     list(attentions[0].shape[-3:]							)			,  [self.model_tester.num_heads[0], window_size_squared, window_size_squared]			,  )
                 _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							len(__lowerCamelCase							)

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

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

                 _SCREAMING_SNAKE_CASE				:		Dict  			=							outputs.attentions

                 self.assertEqual(len(__lowerCamelCase							)			,  __lowerCamelCase							)

                 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 	lowerCAmelCase__(       unittest.TestCase			):






       '''simple docstring'''


       def 			UpperCamelCase_	(					self							)	->   Any:
            _SCREAMING_SNAKE_CASE				:		int  			=							SwinaSRImageProcessor()
            _SCREAMING_SNAKE_CASE				:		Any  			=							SwinaSRForImageSuperResolution.from_pretrained("caidas/swin2SR-classical-sr-x2-64"							).to(__lowerCamelCase							)

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

            # forward pass
            with torch.no_grad():
                 _SCREAMING_SNAKE_CASE				:		int  			=							model(**__lowerCamelCase							)

            # verify the logits
            _SCREAMING_SNAKE_CASE				:		int  			=							torch.Size([1, 3, 9_7_6, 1_2_9_6]							)
            self.assertEqual(outputs.reconstruction.shape			,  __lowerCamelCase							)
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							torch.tensor(
                [[0.5458, 0.5546, 0.5638], [0.5526, 0.5565, 0.5651], [0.5396, 0.5426, 0.5621]]							).to(__lowerCamelCase							)
            self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]			,  __lowerCamelCase			,  atol=1E-4							)							)





'''simple docstring'''


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)
_snake_case      :      Optional[int]   							=		'\\n'

_snake_case      :      Optional[Any]   							=		'\\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'

_snake_case      :      Union[str, Any]   							=		'\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'

_snake_case      :      Dict   							=		['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
_snake_case      :      List[str]   							=		''

try:
				from jiwer import transforms as tr

				_snake_case      :      Optional[Any]   							=		True
except ImportError:
				_snake_case      :      Any   							=		False

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

				class 			A    (		tr.AbstractTransform    ):







											def __init__(  self       :  Any							,			lowerCAmelCase_       :  str = " "					)			->							Dict:


																		"""simple docstring"""


																		_a	     =				sentence_delimiter







											def    __lowerCAmelCase			(  self       :  Union[str, Any]							,			lowerCAmelCase_       :  str					)			->							Tuple:


																		"""simple docstring"""


																		return list(lowerCAmelCase_					)







											def    __lowerCAmelCase			(  self       :  Optional[int]							,			lowerCAmelCase_       :  List[str]					)			->							List[str]:


																		"""simple docstring"""


																		_a	     =				[]
																		for sent_idx, sentence in enumerate(lowerCAmelCase_					):
																									chars.extend(self.process_string(lowerCAmelCase_					)					)
																									if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(lowerCAmelCase_					) - 1:
																																chars.append(self.sentence_delimiter					)
																		return chars



				_snake_case      :      List[Any]   							=		tr.Compose(
				    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
				)
elif _jiwer_available:
				_snake_case      :      Dict   							=		tr.Compose(
				    [
				        tr.RemoveMultipleSpaces(),
				        tr.Strip(),
				        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
				        tr.ReduceToListOfListOfChars(),
				    ]
				)
else:
				_snake_case      :      Dict   							=		None
def 		snake_case_    (UpperCamelCase       :  Optional[Any] ,						UpperCamelCase       :  List[str]      ):





							'''simple docstring'''


							return float((preds == labels).mean()      )
def 		snake_case_    (UpperCamelCase       :  Optional[int] ,						UpperCamelCase       :  Optional[int]      ):





							'''simple docstring'''


							return {
							    "f1": float(fa_score(y_true=UpperCamelCase ,						y_pred=UpperCamelCase ,						average='''macro'''      )      ),
							    "accuracy": simple_accuracy(UpperCamelCase ,						UpperCamelCase      ),
							}
def 		snake_case_    (UpperCamelCase       :  Optional[int] ,						UpperCamelCase       :  Any ,						UpperCamelCase       :  Optional[Any]="exp" ,						UpperCamelCase       :  Optional[int]=None ,						UpperCamelCase       :  Tuple=False ,						UpperCamelCase       :  Dict=False ,						UpperCamelCase       :  List[str]=None ,						UpperCamelCase       :  Tuple=False ,						):





							'''simple docstring'''


							_a	     =				[[label] for label in labels]
							_a	     =				list(UpperCamelCase      )
							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"`.'''      )

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





							'''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:
														_a	     =				compute_measures(UpperCamelCase ,						UpperCamelCase      )['''wer''']

														_a	     =				compute_measures(UpperCamelCase ,						UpperCamelCase ,						truth_transform=UpperCamelCase ,						hypothesis_transform=UpperCamelCase      )['''wer''']
														return {"wer": wer, "cer": cer}
							else:

														def compute_score(UpperCamelCase       :  Tuple ,						UpperCamelCase       :  Optional[int] ,						UpperCamelCase       :  Dict="wer"      ):
																					_a	     =				0
																					_a	     =				0
																					for prediction, reference in zip(UpperCamelCase ,						UpperCamelCase      ):
																												if score_type == "wer":
																																			_a	     =				compute_measures(UpperCamelCase ,						UpperCamelCase      )
																												elif score_type == "cer":
																																			_a	     =				compute_measures(
																																			    UpperCamelCase ,						UpperCamelCase ,						truth_transform=UpperCamelCase ,						hypothesis_transform=UpperCamelCase      )
																												incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
																												total += measures["substitutions"] + measures["deletions"] + measures["hits"]
																					return incorrect / total

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

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







							def    __lowerCAmelCase			(  self       :  Tuple					)			->							Dict:


														"""simple docstring"""


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

														_a	     =				'''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(lowerCAmelCase_					), '''references''': datasets.Value(lowerCAmelCase_					)}					)							,			codebase_urls=[]							,			reference_urls=[]							,			format='''numpy'''							,			)







							def    __lowerCAmelCase			(  self       :  Optional[int]							,			lowerCAmelCase_       :  Union[str, Any]							,			lowerCAmelCase_       :  Optional[Any]							,			lowerCAmelCase_       :  List[Any]=None							,			lowerCAmelCase_       :  int=None					)			->							Tuple:


														"""simple docstring"""


														_a	     =				bleu_kwargs if bleu_kwargs is not None else {}
														_a	     =				wer_kwargs if wer_kwargs is not None else {}

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

