



'''simple docstring'''


from typing import List

import jiwer
import jiwer.transforms as tr
from packaging import version

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


_lowerCamelCase	:       Tuple      	=	""


if version.parse(importlib_metadata.version("jiwer")) < version.parse("2.3.0"):

   class  SCREAMING_SNAKE_CASE (  tr.AbstractTransform		):






       """simple docstring"""





       def __init__(  self      :					Tuple  ,						UpperCamelCase__      :					str = " " ):


          """simple docstring"""







          UpperCamelCase					=  sentence_delimiter






       def  A       (  self      :					List[Any]  ,						UpperCamelCase__      :					str ):


          """simple docstring"""







          return list(UpperCamelCase__ )






       def  A       (  self      :					str  ,						UpperCamelCase__      :					List[str] ):


          """simple docstring"""







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

   _lowerCamelCase	:       int      	=	tr.Compose(
       [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
   )
else:
   _lowerCamelCase	:       str      	=	tr.Compose(
       [
           tr.RemoveMultipleSpaces(),
           tr.Strip(),
           tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
           tr.ReduceToListOfListOfChars(),
       ]
   )


_lowerCamelCase	:       Tuple      	=	"\\n@inproceedings{inproceedings,\n    author = {Morris, Andrew and Maier, Viktoria and Green, Phil},\n    year = {2004},\n    month = {01},\n    pages = {},\n    title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}\n}\n"

_lowerCamelCase	:       int      	=	"\\nCharacter error rate (CER) is a common metric of the performance of an automatic speech recognition system.\n\nCER is similar to Word Error Rate (WER), but operates on character instead of word. Please refer to docs of WER for further information.\n\nCharacter error rate can be computed as:\n\nCER = (S + D + I) / N = (S + D + I) / (S + D + C)\n\nwhere\n\nS is the number of substitutions,\nD is the number of deletions,\nI is the number of insertions,\nC is the number of correct characters,\nN is the number of characters in the reference (N=S+D+C).\n\nCER's output is not always a number between 0 and 1, in particular when there is a high number of insertions. This value is often associated to the percentage of characters that were incorrectly predicted. The lower the value, the better the\nperformance of the ASR system with a CER of 0 being a perfect score.\n"

_lowerCamelCase	:       str      	=	"\nComputes CER score of transcribed segments against references.\nArgs:\n    references: list of references for each speech input.\n    predictions: list of transcribtions to score.\n    concatenate_texts: Whether or not to concatenate sentences before evaluation, set to True for more accurate result.\nReturns:\n    (float): the character error rate\n\nExamples:\n\n    >>> predictions = [\"this is the prediction\", \"there is an other sample\"]\n    >>> references = [\"this is the reference\", \"there is another one\"]\n    >>> cer = datasets.load_metric(\"cer\")\n    >>> cer_score = cer.compute(predictions=predictions, references=references)\n    >>> print(cer_score)\n    0.34146341463414637\n"

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






    """simple docstring"""





    def  A       (  self      :					int ):


       """simple docstring"""







       return datasets.MetricInfo(
           description=_DESCRIPTION  ,						citation=_CITATION  ,						inputs_description=_KWARGS_DESCRIPTION  ,						features=datasets.Features(
               {
                   'predictions': datasets.Value('string'  ,						id='sequence' ),
                   'references': datasets.Value('string'  ,						id='sequence' ),
               } )  ,						codebase_urls=['https://github.com/jitsi/jiwer/']  ,						reference_urls=[
               'https://en.wikipedia.org/wiki/Word_error_rate',
               'https://sites.google.com/site/textdigitisation/qualitymeasures/computingerrorrates',
           ]  ,						)






    def  A       (  self      :					str  ,						UpperCamelCase__      :					Optional[int]  ,						UpperCamelCase__      :					List[str]  ,						UpperCamelCase__      :					Any=False ):


       """simple docstring"""







       if concatenate_texts:
          return jiwer.compute_measures(
              UpperCamelCase__  ,						UpperCamelCase__  ,						truth_transform=UpperCamelCase__  ,						hypothesis_transform=UpperCamelCase__  ,						)["wer"]

       UpperCamelCase					=  0
       UpperCamelCase					=  0
       for prediction, reference in zip(UpperCamelCase__  ,						UpperCamelCase__ ):
          UpperCamelCase					=  jiwer.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


import warnings

from transformers import AutoTokenizer
from transformers.utils import is_torch_available
from transformers.utils.generic import ExplicitEnum

from ...processing_utils import ProcessorMixin


if is_torch_available():
      import torch


class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
  """simple docstring"""







  lowerCamelCase__   =  '''char'''
  lowerCamelCase__   =  '''bpe'''
  lowerCamelCase__   =  '''wp'''



A   :     Tuple       =				(DecodeType.CHARACTER, DecodeType.BPE, DecodeType.WORDPIECE)


class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
  """simple docstring"""







  lowerCamelCase__   =  ['''image_processor''', '''char_tokenizer''']
  lowerCamelCase__   =  '''ViTImageProcessor'''
  lowerCamelCase__   =  '''MgpstrTokenizer'''







  def __init__(							self       :				Optional[Any]     ,   __magic_name__       :				Tuple=None     ,   __magic_name__       :				int=None     ,   **__magic_name__       :				Optional[Any]      )     ->		str:
        SCREAMING_SNAKE_CASE_      =     None
        if "feature_extractor" in kwargs:
              warnings.warn(
                  "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
                  " instead."     ,   __magic_name__     ,   )
              SCREAMING_SNAKE_CASE_      =     kwargs.pop("feature_extractor"      )

        SCREAMING_SNAKE_CASE_      =     image_processor if image_processor is not None else feature_extractor
        if image_processor is None:
              raise ValueError("You need to specify an `image_processor`."      )
        if tokenizer is None:
              raise ValueError("You need to specify a `tokenizer`."      )

        SCREAMING_SNAKE_CASE_      =     tokenizer
        SCREAMING_SNAKE_CASE_      =     AutoTokenizer.from_pretrained("gpt2"      )
        SCREAMING_SNAKE_CASE_      =     AutoTokenizer.from_pretrained("bert-base-uncased"      )

        super().__init__(__magic_name__     ,   __magic_name__      )







  def __call__(							self       :				Dict     ,   __magic_name__       :				Union[str, Any]=None     ,   __magic_name__       :				Union[str, Any]=None     ,   __magic_name__       :				Dict=None     ,   **__magic_name__       :				Tuple      )     ->		int:
        if images is None and text is None:
              raise ValueError("You need to specify either an `images` or `text` input to process."      )

        if images is not None:
              SCREAMING_SNAKE_CASE_      =     self.image_processor(__magic_name__     ,   return_tensors=__magic_name__     ,   **__magic_name__      )
        if text is not None:
              SCREAMING_SNAKE_CASE_      =     self.char_tokenizer(__magic_name__     ,   return_tensors=__magic_name__     ,   **__magic_name__      )

        if text is None:
              return inputs
        elif images is None:
              return encodings
        else:
              SCREAMING_SNAKE_CASE_      =     encodings["input_ids"]
              return inputs







  def       __A   (							self       :				Tuple     ,   __magic_name__       :				int      )     ->		Any:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     sequences
        SCREAMING_SNAKE_CASE_      =     char_preds.size(0      )

        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self._decode_helper(__magic_name__     ,   "char"      )
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self._decode_helper(__magic_name__     ,   "bpe"      )
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self._decode_helper(__magic_name__     ,   "wp"      )

        SCREAMING_SNAKE_CASE_      =     []
        SCREAMING_SNAKE_CASE_      =     []
        for i in range(__magic_name__      ):
              SCREAMING_SNAKE_CASE_      =     [char_scores[i], bpe_scores[i], wp_scores[i]]
              SCREAMING_SNAKE_CASE_      =     [char_strs[i], bpe_strs[i], wp_strs[i]]
              SCREAMING_SNAKE_CASE_      =     scores.index(max(__magic_name__      )      )
              final_strs.append(strs[max_score_index]      )
              final_scores.append(scores[max_score_index]      )

        SCREAMING_SNAKE_CASE_      =     {}
        SCREAMING_SNAKE_CASE_      =     final_strs
        SCREAMING_SNAKE_CASE_      =     final_scores
        SCREAMING_SNAKE_CASE_      =     char_strs
        SCREAMING_SNAKE_CASE_      =     bpe_strs
        SCREAMING_SNAKE_CASE_      =     wp_strs
        return out







  def       __A   (							self       :				int     ,   __magic_name__       :				List[Any]     ,   __magic_name__       :				str      )     ->		Any:
        if format == DecodeType.CHARACTER:
              SCREAMING_SNAKE_CASE_      =     self.char_decode
              SCREAMING_SNAKE_CASE_      =     1
              SCREAMING_SNAKE_CASE_      =     "[s]"
        elif format == DecodeType.BPE:
              SCREAMING_SNAKE_CASE_      =     self.bpe_decode
              SCREAMING_SNAKE_CASE_      =     2
              SCREAMING_SNAKE_CASE_      =     "#"
        elif format == DecodeType.WORDPIECE:
              SCREAMING_SNAKE_CASE_      =     self.wp_decode
              SCREAMING_SNAKE_CASE_      =     102
              SCREAMING_SNAKE_CASE_      =     "[SEP]"
        else:
              raise ValueError(F'''Format {format} is not supported.'''      )

        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     [], []
        SCREAMING_SNAKE_CASE_      =     pred_logits.size(0      )
        SCREAMING_SNAKE_CASE_      =     pred_logits.size(1      )
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     pred_logits.topk(1     ,   dim=-1     ,   largest=__magic_name__     ,   sorted=__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     preds_index.view(-1     ,   __magic_name__      )[:, 1:]
        SCREAMING_SNAKE_CASE_      =     decoder(__magic_name__      )
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     torch.nn.functional.softmax(__magic_name__     ,   dim=2      ).max(dim=2      )
        SCREAMING_SNAKE_CASE_      =     preds_max_prob[:, 1:]

        for index in range(__magic_name__      ):
              SCREAMING_SNAKE_CASE_      =     preds_str[index].find(__magic_name__      )
              SCREAMING_SNAKE_CASE_      =     preds_str[index][:pred_eos]
              SCREAMING_SNAKE_CASE_      =     preds_index[index].cpu().tolist()
              SCREAMING_SNAKE_CASE_      =     pred_index.index(__magic_name__      ) if eos_token in pred_index else -1
              SCREAMING_SNAKE_CASE_      =     preds_max_prob[index][: pred_eos_index + 1]
              SCREAMING_SNAKE_CASE_      =     pred_max_prob.cumprod(dim=0      )[-1] if pred_max_prob.nelement() != 0 else 0.0
              dec_strs.append(__magic_name__      )
              conf_scores.append(__magic_name__      )

        return dec_strs, conf_scores







  def       __A   (							self       :				Any     ,   __magic_name__       :				Dict      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     [seq.replace(" "     ,   ""      ) for seq in self.char_tokenizer.batch_decode(__magic_name__      )]
        return decode_strs







  def       __A   (							self       :				Any     ,   __magic_name__       :				Union[str, Any]      )     ->		Tuple:
        return self.bpe_tokenizer.batch_decode(__magic_name__      )







  def       __A   (							self       :				str     ,   __magic_name__       :				Dict      )     ->		List[Any]:
        SCREAMING_SNAKE_CASE_      =     [seq.replace(" "     ,   ""      ) for seq in self.wp_tokenizer.batch_decode(__magic_name__      )]
        return decode_strs


