





"""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_					:						List[Any]      = '\\n'

lowerCamelCase_					:						List[str]      = '\\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_					:						int      = ['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
lowerCamelCase_					:						Optional[int]      = ''

try:
   from jiwer import transforms as tr

   lowerCamelCase_					:						Optional[int]      = True
except ImportError:
   lowerCamelCase_					:						List[Any]      = False

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

   class 			_UpperCAmelCase  (       tr.AbstractTransform		):



         '''simple docstring'''

         def __init__(					self ,				snake_case_ = " "  ):

           """simple docstring"""

           A_  :	Optional[int]    						=  sentence_delimiter

         def  lowerCamelCase_      (					self ,				snake_case_  ):

           """simple docstring"""

           return list(snake_case_  )

         def  lowerCamelCase_      (					self ,				snake_case_  ):

           """simple docstring"""

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


   lowerCamelCase_					:						int      = tr.Compose(
       [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
   )
elif _jiwer_available:
   lowerCamelCase_					:						Union[str, Any]      = tr.Compose(
       [
           tr.RemoveMultipleSpaces(),
           tr.Strip(),
           tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
           tr.ReduceToListOfListOfChars(),
       ]
   )
else:
   lowerCamelCase_					:						Tuple      = None





def 						UpperCAmelCase__		(					_UpperCAmelCase			, _UpperCAmelCase ):






  """simple docstring"""





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





def 						UpperCAmelCase__		(					_UpperCAmelCase			, _UpperCAmelCase ):






  """simple docstring"""





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





def 						UpperCAmelCase__		(					_UpperCAmelCase			, _UpperCAmelCase			, _UpperCAmelCase="exp"			, _UpperCAmelCase=None			, _UpperCAmelCase=False			, _UpperCAmelCase=False			, _UpperCAmelCase=None			, _UpperCAmelCase=False			, ):






  """simple docstring"""





  A_  :	str    						=  [[label] for label in labels]
  A_  :	Dict    						=  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_  :	Optional[int]    						=  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_  :	int    						=  [[refs[i] for refs in labels] for i in range(_UpperCAmelCase )]
  A_  :	Optional[int]    						=  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 						UpperCAmelCase__		(					_UpperCAmelCase			, _UpperCAmelCase			, _UpperCAmelCase			, _UpperCAmelCase ):






  """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_  :	str    						=  compute_measures(_UpperCAmelCase			, _UpperCAmelCase )['wer']

    A_  :	Dict    						=  compute_measures(_UpperCAmelCase			, _UpperCAmelCase			, truth_transform=_UpperCAmelCase			, hypothesis_transform=_UpperCAmelCase )['wer']
    return {"wer": wer, "cer": cer}
  else:

    def compute_score(_UpperCAmelCase			, _UpperCAmelCase			, _UpperCAmelCase="wer" ):
      A_  :	Tuple    						=  0
      A_  :	int    						=  0
      for prediction, reference in zip(_UpperCAmelCase			, _UpperCAmelCase ):
        if score_type == "wer":
          A_  :	Any    						=  compute_measures(_UpperCAmelCase			, _UpperCAmelCase )
        elif score_type == "cer":
          A_  :	Tuple    						=  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 			_UpperCAmelCase  (       datasets.Metric		):



      '''simple docstring'''

      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

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

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

      def  lowerCamelCase_      (					self ,				snake_case_ ,				snake_case_ ,				snake_case_=None ,				snake_case_=None  ):

        """simple docstring"""

        A_  :	List[Any]    						=  bleu_kwargs if bleu_kwargs is not None else {}
        A_  :	List[Any]    						=  wer_kwargs if wer_kwargs is not None else {}

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






"""simple docstring"""




# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
    is_vision_available,
)


lowerCamelCase_					:						Any      = {
    'configuration_tvlt': ['TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TvltConfig'],
    'feature_extraction_tvlt': ['TvltFeatureExtractor'],
    'processing_tvlt': ['TvltProcessor'],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase_					:						Union[str, Any]      = [
       'TVLT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TvltModel',
       'TvltForPreTraining',
       'TvltForAudioVisualClassification',
       'TvltPreTrainedModel',
   ]

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase_					:						List[Any]      = ['TvltImageProcessor']


if TYPE_CHECKING:
   from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
   from .processing_tvlt import TvltProcessor
   from .feature_extraction_tvlt import TvltFeatureExtractor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tvlt import (
          TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TvltForAudioVisualClassification,
          TvltForPreTraining,
          TvltModel,
          TvltPreTrainedModel,
      )

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .image_processing_tvlt import TvltImageProcessor


else:
   import sys

   lowerCamelCase_					:						Optional[int]      = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)