code: 
  
  
  
  
  '''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)
  _lowerCamelCase							:		Tuple							=						'\\n'
  
  _lowerCamelCase							:		int							=						'\\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'
  
  _lowerCamelCase							:		str							=						'\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'
  
  _lowerCamelCase							:		Any							=						['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
  _lowerCamelCase							:		Tuple							=						''
  
  try:
  						from jiwer import transforms as tr
  
  						_lowerCamelCase							:		List[str]							=						True
  except ImportError:
  						_lowerCamelCase							:		List[str]							=						False
  
  if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):
  
  
  
  
  
  						class   lowerCamelCase_							( tr.AbstractTransform							):
  
  
  
  
  											'''simple docstring'''
  
  
  
  
  
  
  											def __init__(					self,						__UpperCamelCase = " "				):
  													_snake_case			 = sentence_delimiter
  
  
  
  
  
  
  											def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase				):
  													return list(SCREAMING_SNAKE_CASE_				)
  
  
  
  
  
  
  											def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase				):
  													_snake_case			 = []
  													for sent_idx, sentence in enumerate(SCREAMING_SNAKE_CASE_				):
  															chars.extend(self.process_string(SCREAMING_SNAKE_CASE_				)				)
  															if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(SCREAMING_SNAKE_CASE_				) - 1:
  																	chars.append(self.sentence_delimiter				)
  													return chars
  
  
  
  
  						_lowerCamelCase							:		List[Any]							=						tr.Compose(
  						    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
  						)
  elif _jiwer_available:
  						_lowerCamelCase							:		Optional[int]							=						tr.Compose(
  						    [
  						        tr.RemoveMultipleSpaces(),
  						        tr.Strip(),
  						        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
  						        tr.ReduceToListOfListOfChars(),
  						    ]
  						)
  else:
  						_lowerCamelCase							:		Tuple							=						None
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return float((preds == labels).mean()						)
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return {
  		    "f1": float(fa_score(y_true=snake_case__		,							y_pred=snake_case__		,							average="macro"						)						),
  		    "accuracy": simple_accuracy(snake_case__		,							snake_case__						),
  		}
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_		,							lowercase_="exp"		,							lowercase_=None		,							lowercase_=False		,							lowercase_=False		,							lowercase_=None		,							lowercase_=False		,							):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = [[label] for label in labels]
  		_snake_case			 = list(snake_case__						)
  		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\"`."						)
  
  		_snake_case			 = len(labels[0]						)
  		if any(len(snake_case__						) != references_per_prediction for refs in labels						):
  				raise ValueError("Sacrebleu requires the same number of references for each prediction"						)
  		_snake_case			 = [[refs[i] for refs in labels] for i in range(snake_case__						)]
  		_snake_case			 = scb.corpus_bleu(
  		    snake_case__		,							snake_case__		,							smooth_method=snake_case__		,							smooth_value=snake_case__		,							force=snake_case__		,							lowercase=snake_case__		,							use_effective_order=snake_case__		,							**({"tokenize": tokenize} if tokenize else {})		,							)
  		return {"bleu": output.score}
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_		,							lowercase_		,							lowercase_		,							lowercase_						):
  
  
  
  		'''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:
  				_snake_case			 = compute_measures(snake_case__		,							snake_case__						)['wer']
  
  				_snake_case			 = compute_measures(snake_case__		,							snake_case__		,							truth_transform=snake_case__		,							hypothesis_transform=snake_case__						)['wer']
  				return {"wer": wer, "cer": cer}
  		else:
  
  				def compute_score(lowercase_		,							lowercase_		,							lowercase_="wer"						):
  						_snake_case			 = 0
  						_snake_case			 = 0
  						for prediction, reference in zip(snake_case__		,							snake_case__						):
  								if score_type == "wer":
  										_snake_case			 = compute_measures(snake_case__		,							snake_case__						)
  								elif score_type == "cer":
  										_snake_case			 = compute_measures(
  										    snake_case__		,							snake_case__		,							truth_transform=snake_case__		,							hypothesis_transform=snake_case__						)
  								incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
  								total += measures["substitutions"] + measures["deletions"] + measures["hits"]
  						return incorrect / total
  
  				return {"wer": compute_score(snake_case__		,							snake_case__		,							"wer"						), "cer": compute_score(snake_case__		,							snake_case__		,							"cer"						)}
  
  
  
  
  
  @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION							)
  class   lowerCamelCase_							( datasets.Metric							):
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self				):
  							if self.config_name not in _CONFIG_NAMES:
  									raise KeyError(f'''You should supply a configuration name selected in {_CONFIG_NAMES}'''				)
  
  							_snake_case			 = '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(SCREAMING_SNAKE_CASE_				), "references": datasets.Value(SCREAMING_SNAKE_CASE_				)}				),						codebase_urls=[],						reference_urls=[],						format="numpy",						)
  
  
  
  
  
  
  					def        __SCREAMING_SNAKE_CASE			(					self,						__UpperCamelCase,						__UpperCamelCase,						__UpperCamelCase=None,						__UpperCamelCase=None				):
  							_snake_case			 = bleu_kwargs if bleu_kwargs is not None else {}
  							_snake_case			 = wer_kwargs if wer_kwargs is not None else {}
  
  							if self.config_name == "fleurs-lang_id":
  									return {"accuracy": simple_accuracy(SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				)}
  							elif self.config_name == "minds14":
  									return fa_and_simple_accuracy(SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_				)
  							elif self.config_name == "covost2":
  									_snake_case			 = bleu_kwargs.pop("smooth_method",						"exp"				)
  									_snake_case			 = bleu_kwargs.pop("smooth_value",						SCREAMING_SNAKE_CASE_				)
  									_snake_case			 = bleu_kwargs.pop("force",						SCREAMING_SNAKE_CASE_				)
  									_snake_case			 = bleu_kwargs.pop("lowercase",						SCREAMING_SNAKE_CASE_				)
  									_snake_case			 = bleu_kwargs.pop("tokenize",						SCREAMING_SNAKE_CASE_				)
  									_snake_case			 = bleu_kwargs.pop("use_effective_order",						SCREAMING_SNAKE_CASE_				)
  									return bleu(
  									    preds=SCREAMING_SNAKE_CASE_,						labels=SCREAMING_SNAKE_CASE_,						smooth_method=SCREAMING_SNAKE_CASE_,						smooth_value=SCREAMING_SNAKE_CASE_,						force=SCREAMING_SNAKE_CASE_,						lowercase=SCREAMING_SNAKE_CASE_,						tokenize=SCREAMING_SNAKE_CASE_,						use_effective_order=SCREAMING_SNAKE_CASE_,						)
  							elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
  									_snake_case			 = wer_kwargs.pop("concatenate_texts",						SCREAMING_SNAKE_CASE_				)
  									return wer_and_cer(SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_,						SCREAMING_SNAKE_CASE_,						self.config_name				)
  							else:
  									raise KeyError(f'''You should supply a configuration name selected in {_CONFIG_NAMES}'''				)
  
  
  
  
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import importlib
  import importlib.metadata
  import os
  import warnings
  from distutils.util import strtobool
  from functools import lru_cache
  
  import torch
  from packaging import version
  from packaging.version import parse
  
  from .environment import parse_flag_from_env
  from .versions import compare_versions, is_torch_version
  
  
  try:
  						import torch_xla.core.xla_model as xm  # noqa: F401
  
  						_lowerCamelCase							:		int										=						True
  except ImportError:
  						_lowerCamelCase							:		List[str]										=						False
  
  
  # Cache this result has it's a C FFI call which can be pretty time-consuming
  _lowerCamelCase							:		List[Any]										=						torch.distributed.is_available()
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = importlib.util.find_spec(lowercase_						) is not None
  		if package_exists:
  				try:
  						_snake_case			 = importlib.metadata.metadata(lowercase_						)
  						return True
  				except importlib.metadata.PackageNotFoundError:
  						return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _torch_distributed_available
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		try:
  				pass
  		except ImportError:
  				print(
  				    "Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"
  				    " detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"
  				    " Bindings for PyTorch*."						)
  		return (
  		    importlib.util.find_spec("torch_ccl"						) is not None
  		    or importlib.util.find_spec("oneccl_bindings_for_pytorch"						) is not None
  		)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return importlib.metadata.version("oneccl_bind_pt"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("transformer_engine"						)
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=True						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if torch.cuda.is_available():
  				return False
  		if _tpu_available and check_device:
  				try:
  						# Will raise a RuntimeError if no XLA configuration is found
  						_snake_case			 = xm.xla_device()
  						return True
  				except RuntimeError:
  						return False
  		return _tpu_available
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("deepspeed"						)
  
  
  
  
  
  
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if is_tpu_available():
  				return not ignore_tpu
  		if torch.cuda.is_available():
  				return torch.cuda.is_bfaa_supported()
  		if is_npu_available():
  				return False
  		return True
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = _is_package_available("bitsandbytes"						)
  		if package_exists:
  				_snake_case			 = version.parse(importlib.metadata.version("bitsandbytes"						)						)
  				return compare_versions(lowercase_		,							">="		,							"0.39.0"						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		_snake_case			 = _is_package_available("bitsandbytes"						)
  		if package_exists:
  				_snake_case			 = version.parse(importlib.metadata.version("bitsandbytes"						)						)
  				return compare_versions(lowercase_		,							">="		,							"0.37.2"						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("bitsandbytes"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"		,							"False"						)						) == 1:
  				_snake_case			 = importlib.util.find_spec("megatron"						) is not None
  				if package_exists:
  						try:
  								_snake_case			 = parse(importlib.metadata.version("megatron-lm"						)						)
  								return compare_versions(lowercase_		,							">="		,							"2.2.0"						)
  						except Exception as e:
  								warnings.warn(f'''Parse Megatron version failed. Exception:{e}'''						)
  								return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("safetensors"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("transformers"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("datasets"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("aim"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("tensorboard"						) or _is_package_available("tensorboardX"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("wandb"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("comet_ml"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("boto3"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if _is_package_available("rich"						):
  				if "ACCELERATE_DISABLE_RICH" in os.environ:
  						warnings.warn(
  						    "`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`."						)
  						return not parse_flag_from_env("ACCELERATE_DISABLE_RICH"		,							lowercase_						)
  				return parse_flag_from_env("ACCELERATE_ENABLE_RICH"		,							lowercase_						)
  		return False
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("sagemaker"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("tqdm"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return _is_package_available("mlflow"						)
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return is_torch_version(">="		,							"1.12"						) and torch.backends.mps.is_available() and torch.backends.mps.is_built()
  
  
  
  
  
  
  def 	_lowercase	(			):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def get_major_and_minor_from_version(lowercase_						):
  				return str(version.parse(lowercase_						).major						) + "." + str(version.parse(lowercase_						).minor						)
  
  		_snake_case			 = importlib.metadata.version("torch"						)
  		if importlib.util.find_spec("intel_extension_for_pytorch"						) is None:
  				return False
  		_snake_case			 = "N/A"
  		try:
  				_snake_case			 = importlib.metadata.version("intel_extension_for_pytorch"						)
  		except importlib.metadata.PackageNotFoundError:
  				return False
  		_snake_case			 = get_major_and_minor_from_version(_torch_version						)
  		_snake_case			 = get_major_and_minor_from_version(_ipex_version						)
  		if torch_major_and_minor != ipex_major_and_minor:
  				warnings.warn(
  				    f'''Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,'''
  				    f''' but PyTorch {_torch_version} is found. Please switch to the matching version and run again.'''						)
  				return False
  		return True
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if importlib.util.find_spec("torch"						) is None or importlib.util.find_spec("torch_npu"						) is None:
  				return False
  
  		import torch
  		import torch_npu  # noqa: F401
  
  		if check_device:
  				try:
  						# Will raise a RuntimeError if no NPU is found
  						_snake_case			 = torch.npu.device_count()
  						return torch.npu.is_available()
  				except RuntimeError:
  						return False
  		return hasattr(lowercase_		,							"npu"						) and torch.npu.is_available()
  
  
  
  
  
  
  @lru_cache
  def 	_lowercase	(			lowercase_=False						):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		if not parse_flag_from_env("ACCELERATE_USE_XPU"		,							default=lowercase_						):
  				return False
  		if is_ipex_available():
  				import torch
  
  				if is_torch_version("<="		,							"1.12"						):
  						return False
  		else:
  				return False
  
  		import intel_extension_for_pytorch  # noqa: F401
  
  		if check_device:
  				try:
  						# Will raise a RuntimeError if no XPU  is found
  						_snake_case			 = torch.xpu.device_count()
  						return torch.xpu.is_available()
  				except RuntimeError:
  						return False
  		return hasattr(lowercase_		,							"xpu"						) and torch.xpu.is_available()
  
  
  
  
  
  