

'''simple docstring'''
import unittest

from transformers import PegasusTokenizer, PegasusTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


_snake_case         =  get_tests_dir('fixtures/test_sentencepiece_no_bos.model')


@require_sentencepiece
@require_tokenizers
class        a__  (							_UpperCamelCase  ,				unittest.TestCase  ):
   _SCREAMING_SNAKE_CASE   :					Union[str, Any]     	=							PegasusTokenizer
   _SCREAMING_SNAKE_CASE   :					List[Any]     	=							PegasusTokenizerFast
   _SCREAMING_SNAKE_CASE   :					Union[str, Any]     	=							True
   _SCREAMING_SNAKE_CASE   :					int     	=							True


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      super().setUp()

      # We have a SentencePiece fixture for testing
      _lowercase      :				List[str]      					=       PegasusTokenizer(_SCREAMING_SNAKE_CASE  )
      tokenizer.save_pretrained(self.tmpdirname  )


   @cached_property
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      return PegasusTokenizer.from_pretrained("google/pegasus-large"  )


   def 						_lowerCamelCase       (			self      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return PegasusTokenizer.from_pretrained(self.tmpdirname      ,    **_SCREAMING_SNAKE_CASE  )


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase  ):





      """simple docstring"""





      return ("This is a test", "This is a test")


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				int      					=       "</s>"
      _lowercase      :				str      					=       1

      self.assertEqual(self.get_tokenizer()._convert_token_to_id(_SCREAMING_SNAKE_CASE  )      ,    _SCREAMING_SNAKE_CASE  )
      self.assertEqual(self.get_tokenizer()._convert_id_to_token(_SCREAMING_SNAKE_CASE  )      ,    _SCREAMING_SNAKE_CASE  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[Any]      					=       list(self.get_tokenizer().get_vocab().keys()  )

      self.assertEqual(vocab_keys[0]      ,    "<pad>"  )
      self.assertEqual(vocab_keys[1]      ,    "</s>"  )
      self.assertEqual(vocab_keys[-1]      ,    "v"  )
      self.assertEqual(len(_SCREAMING_SNAKE_CASE  )      ,    1103  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      self.assertEqual(self.get_tokenizer().vocab_size      ,    1103  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Any      					=       self.rust_tokenizer_class.from_pretrained(self.tmpdirname  )
      _lowercase      :				Optional[Any]      					=       self.tokenizer_class.from_pretrained(self.tmpdirname  )
      _lowercase      :				Optional[int]      					=       (
          "Let\'s see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important"
          " </s> <pad> <pad> <pad>"
      )
      _lowercase      :				Dict      					=       rust_tokenizer([raw_input_str]      ,    return_tensors=_SCREAMING_SNAKE_CASE      ,    add_special_tokens=_SCREAMING_SNAKE_CASE  ).input_ids[0]
      _lowercase      :				List[Any]      					=       py_tokenizer([raw_input_str]      ,    return_tensors=_SCREAMING_SNAKE_CASE      ,    add_special_tokens=_SCREAMING_SNAKE_CASE  ).input_ids[0]
      self.assertListEqual(_SCREAMING_SNAKE_CASE      ,    _SCREAMING_SNAKE_CASE  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[int]      					=       self._large_tokenizer
      # <mask_1> masks whole sentence while <mask_2> masks single word
      _lowercase      :				int      					=       "<mask_1> To ensure a <mask_2> flow of bank resolutions."
      _lowercase      :				int      					=       [2, 413, 615, 114, 3, 1971, 113, 1679, 10710, 107, 1]
      _lowercase      :				Optional[Any]      					=       tokenizer([raw_input_str]      ,    return_tensors=_SCREAMING_SNAKE_CASE  ).input_ids[0]
      self.assertListEqual(_SCREAMING_SNAKE_CASE      ,    _SCREAMING_SNAKE_CASE  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				str      					=       self._large_tokenizer
      # The tracebacks for the following asserts are **better** without messages or self.assertEqual
      assert tokenizer.vocab_size == 96103
      assert tokenizer.pad_token_id == 0
      assert tokenizer.eos_token_id == 1
      assert tokenizer.offset == 103
      assert tokenizer.unk_token_id == tokenizer.offset + 2 == 105
      assert tokenizer.unk_token == "<unk>"
      assert tokenizer.model_max_length == 1024
      _lowercase      :				Union[str, Any]      					=       "To ensure a smooth flow of bank resolutions."
      _lowercase      :				Optional[int]      					=       [413, 615, 114, 2291, 1971, 113, 1679, 10710, 107, 1]
      _lowercase      :				int      					=       tokenizer([raw_input_str]      ,    return_tensors=_SCREAMING_SNAKE_CASE  ).input_ids[0]
      self.assertListEqual(_SCREAMING_SNAKE_CASE      ,    _SCREAMING_SNAKE_CASE  )
      assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3]  ) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"]


   @require_torch
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[int]      					=       ["This is going to be way too long." * 150, "short example"]
      _lowercase      :				List[str]      					=       ["not super long but more than 5 tokens", "tiny"]
      _lowercase      :				Optional[int]      					=       self._large_tokenizer(_SCREAMING_SNAKE_CASE      ,    padding=_SCREAMING_SNAKE_CASE      ,    truncation=_SCREAMING_SNAKE_CASE      ,    return_tensors="pt"  )
      _lowercase      :				Optional[Any]      					=       self._large_tokenizer(
          text_target=_SCREAMING_SNAKE_CASE      ,    max_length=5      ,    padding=_SCREAMING_SNAKE_CASE      ,    truncation=_SCREAMING_SNAKE_CASE      ,    return_tensors="pt"  )

      assert batch.input_ids.shape == (2, 1024)
      assert batch.attention_mask.shape == (2, 1024)
      assert targets["input_ids"].shape == (2, 5)
      assert len(_SCREAMING_SNAKE_CASE  ) == 2  # input_ids, attention_mask.






   @slow
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[int]      					=       {"input_ids": [[38979, 143, 18485, 606, 130, 26669, 87686, 121, 54189, 1129, 111, 26669, 87686, 121, 9114, 14787, 121, 13249, 158, 592, 956, 121, 14621, 31576, 143, 62613, 108, 9688, 930, 43430, 11562, 62613, 304, 108, 11443, 897, 108, 9314, 17415, 63399, 108, 11443, 7614, 18316, 118, 4284, 7148, 12430, 143, 1400, 25703, 158, 111, 4284, 7148, 11772, 143, 21297, 1064, 158, 122, 204, 3506, 1754, 1133, 14787, 1581, 115, 33224, 4482, 111, 1355, 110, 29173, 317, 50833, 108, 20147, 94665, 111, 77198, 107, 1], [110, 62613, 117, 638, 112, 1133, 121, 20098, 1355, 79050, 13872, 135, 1596, 53541, 1352, 141, 13039, 5542, 124, 302, 518, 111, 268, 2956, 115, 149, 4427, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [139, 1235, 2799, 18289, 17780, 204, 109, 9474, 1296, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
      # fmt: on

      self.tokenizer_integration_test_util(
          expected_encoding=_SCREAMING_SNAKE_CASE      ,    model_name="google/bigbird-pegasus-large-arxiv"      ,    revision="ba85d0851d708441f91440d509690f1ab6353415"      ,    )




@require_sentencepiece
@require_tokenizers
class        a__  (							_UpperCamelCase  ,				unittest.TestCase  ):
   _SCREAMING_SNAKE_CASE   :					int     	=							PegasusTokenizer
   _SCREAMING_SNAKE_CASE   :					List[str]     	=							PegasusTokenizerFast
   _SCREAMING_SNAKE_CASE   :					Dict     	=							True
   _SCREAMING_SNAKE_CASE   :					Tuple     	=							True


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      super().setUp()

      # We have a SentencePiece fixture for testing
      _lowercase      :				Dict      					=       PegasusTokenizer(_SCREAMING_SNAKE_CASE      ,    offset=0      ,    mask_token_sent=_SCREAMING_SNAKE_CASE      ,    mask_token="[MASK]"  )
      tokenizer.save_pretrained(self.tmpdirname  )


   @cached_property
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      return PegasusTokenizer.from_pretrained("google/bigbird-pegasus-large-arxiv"  )


   def 						_lowerCamelCase       (			self      ,    **_UpperCamelCase  ):





      """simple docstring"""





      return PegasusTokenizer.from_pretrained(self.tmpdirname      ,    **_SCREAMING_SNAKE_CASE  )


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase  ):





      """simple docstring"""





      return ("This is a test", "This is a test")


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				int      					=       self.rust_tokenizer_class.from_pretrained(self.tmpdirname  )
      _lowercase      :				List[str]      					=       self.tokenizer_class.from_pretrained(self.tmpdirname  )
      _lowercase      :				Optional[Any]      					=       (
          "Let\'s see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>"
          " <pad> <pad> <pad>"
      )
      _lowercase      :				List[str]      					=       rust_tokenizer([raw_input_str]      ,    return_tensors=_SCREAMING_SNAKE_CASE      ,    add_special_tokens=_SCREAMING_SNAKE_CASE  ).input_ids[0]
      _lowercase      :				Dict      					=       py_tokenizer([raw_input_str]      ,    return_tensors=_SCREAMING_SNAKE_CASE      ,    add_special_tokens=_SCREAMING_SNAKE_CASE  ).input_ids[0]
      self.assertListEqual(_SCREAMING_SNAKE_CASE      ,    _SCREAMING_SNAKE_CASE  )


   @require_torch
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				int      					=       ["This is going to be way too long." * 1000, "short example"]
      _lowercase      :				Tuple      					=       ["not super long but more than 5 tokens", "tiny"]
      _lowercase      :				List[str]      					=       self._large_tokenizer(_SCREAMING_SNAKE_CASE      ,    padding=_SCREAMING_SNAKE_CASE      ,    truncation=_SCREAMING_SNAKE_CASE      ,    return_tensors="pt"  )
      _lowercase      :				str      					=       self._large_tokenizer(
          text_target=_SCREAMING_SNAKE_CASE      ,    max_length=5      ,    padding=_SCREAMING_SNAKE_CASE      ,    truncation=_SCREAMING_SNAKE_CASE      ,    return_tensors="pt"  )

      assert batch.input_ids.shape == (2, 4096)
      assert batch.attention_mask.shape == (2, 4096)
      assert targets["input_ids"].shape == (2, 5)
      assert len(_SCREAMING_SNAKE_CASE  ) == 2  # input_ids, attention_mask.






   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[Any]      					=       (
          "This is an example string that is used to test the original TF implementation against the HF"
          " implementation"
      )

      _lowercase      :				Tuple      					=       self._large_tokenizer(_SCREAMING_SNAKE_CASE  ).input_ids

      self.assertListEqual(
          _SCREAMING_SNAKE_CASE      ,    [182, 117, 142, 587, 4211, 120, 117, 263, 112, 804, 109, 856, 25016, 3137, 464, 109, 26955, 3137, 1]      ,    )









'''simple docstring'''
import numpy as np
from scipy.spatial.distance import cdist
from sklearn.metrics import fa_score

import datasets


_snake_case         =  '\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n'

_snake_case         =  '\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n'

_snake_case         =  '\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for \'cvit-mkb-clsr\' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for \'cvit-mkb-clsr\' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    "accuracy": Accuracy\n    "f1": F1 score\n    "precision": Precision@10\nExamples:\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wnli\')  # \'wnli\' or any of ["copa", "sna", "csqa", "wstp", "inltkh", "bbca", "iitp-mr", "iitp-pr", "actsa-sc", "md"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wiki-ner\')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0, \'f1\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'cvit-mkb-clsr\')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'precision@10\': 1.0}\n\n'







def  _A		(     snake_case		,							snake_case					)      ->     int:
   return float((preds == labels).mean()					)







def  _A		(     snake_case		,							snake_case					)      ->     Union[str, Any]:
   _lowercase      :				Any      					=       simple_accuracy(snake_case		,							snake_case					)
   _lowercase      :				List[Any]      					=       float(fa_score(y_true=snake_case		,							y_pred=snake_case					)					)
   return {
       "accuracy": acc,
       "f1": fa,
   }







def  _A		(     snake_case		,							snake_case					)      ->     List[str]:
   _lowercase      :				Any      					=       np.array(snake_case					)
   _lowercase      :				Any      					=       np.array(snake_case					)
   _lowercase      :				str      					=       en_sentvecs.shape[0]

   # mean centering
   _lowercase      :				List[Any]      					=       en_sentvecs - np.mean(snake_case		,							axis=0					)
   _lowercase      :				Tuple      					=       in_sentvecs - np.mean(snake_case		,							axis=0					)

   _lowercase      :				Any      					=       cdist(snake_case		,							snake_case		,							"cosine"					)
   _lowercase      :				Any      					=       np.array(range(snake_case					)					)
   _lowercase      :				Dict      					=       sim.argsort(axis=1					)[:, :10]
   _lowercase      :				List[str]      					=       np.any(preds == actual[:, None]		,							axis=1					)
   return float(matches.mean()					)


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


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      if self.config_name not in [
          "wnli",
          "copa",
          "sna",
          "csqa",
          "wstp",
          "inltkh",
          "bbca",
          "cvit-mkb-clsr",
          "iitp-mr",
          "iitp-pr",
          "actsa-sc",
          "md",
          "wiki-ner",
      ]:
         raise KeyError(
             "You should supply a configuration name selected in "
             "[\"wnli\", \"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", "
             "\"cvit-mkb-clsr\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\", "
             "\"wiki-ner\"]"  )
      return datasets.MetricInfo(
          description=_DESCRIPTION      ,    citation=_CITATION      ,    inputs_description=_KWARGS_DESCRIPTION      ,    features=datasets.Features(
              {
                  "predictions": datasets.Value("int64"  )
                  if self.config_name != "cvit-mkb-clsr"
                  else datasets.Sequence(datasets.Value("float32"  )  ),
                  "references": datasets.Value("int64"  )
                  if self.config_name != "cvit-mkb-clsr"
                  else datasets.Sequence(datasets.Value("float32"  )  ),
              }  )      ,    codebase_urls=[]      ,    reference_urls=[]      ,    format="numpy" if self.config_name != "cvit-mkb-clsr" else None      ,    )






   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase  ):





      """simple docstring"""





      if self.config_name == "cvit-mkb-clsr":
         return {"precision@10": precision_at_aa(_UpperCamelCase      ,    _UpperCamelCase  )}
      elif self.config_name in ["wiki-ner"]:
         return acc_and_fa(_UpperCamelCase      ,    _UpperCamelCase  )
      elif self.config_name in [
          "wnli",
          "copa",
          "sna",
          "csqa",
          "wstp",
          "inltkh",
          "bbca",
          "iitp-mr",
          "iitp-pr",
          "actsa-sc",
          "md",
      ]:
         return {"accuracy": simple_accuracy(_UpperCamelCase      ,    _UpperCamelCase  )}
      else:
         raise KeyError(
             "You should supply a configuration name selected in "
             "[\"wnli\", \"copa\", \"sna\", \"csqa\", \"wstp\", \"inltkh\", \"bbca\", "
             "\"cvit-mkb-clsr\", \"iitp-mr\", \"iitp-pr\", \"actsa-sc\", \"md\", "
             "\"wiki-ner\"]"  )






