






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

import datasets


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

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

snake_case    				=		"""
Compute IndicGLUE evaluation metric associated to each IndicGLUE dataset.
Args:
    predictions: list of predictions to score (as int64),
        except for 'cvit-mkb-clsr' where each prediction is a vector (of float32).
    references: list of ground truth labels corresponding to the predictions (as int64),
        except for 'cvit-mkb-clsr' where each reference is a vector (of float32).
Returns: depending on the IndicGLUE subset, one or several of:
    \"accuracy\": Accuracy
    \"f1\": F1 score
    \"precision\": Precision@10
Examples:

    >>> 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\"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'wiki-ner')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> indic_glue_metric = datasets.load_metric('indic_glue', 'cvit-mkb-clsr')
    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]
    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]
    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'precision@10': 1.0}

"""


def   lowerCamelCase__			(     lowercase						,     lowercase				):

  """simple docstring"""






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


def   lowerCamelCase__			(     lowercase						,     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      str							=    simple_accuracy(UpperCamelCase__						,     UpperCamelCase__				)
  SCREAMING_SNAKE_CASE       :      Any							=    float(fa_score(y_true=UpperCamelCase__						,     y_pred=UpperCamelCase__				)				)
  return {
      "accuracy": acc,
      "f1": fa,
  }


def   lowerCamelCase__			(     lowercase						,     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      List[Any]							=    np.array(UpperCamelCase__				)
  SCREAMING_SNAKE_CASE       :      List[str]							=    np.array(UpperCamelCase__				)
  SCREAMING_SNAKE_CASE       :      Any							=    en_sentvecs.shape[0]

  # mean centering
  SCREAMING_SNAKE_CASE       :      List[Any]							=    en_sentvecs - np.mean(UpperCamelCase__						,     axis=0				)
  SCREAMING_SNAKE_CASE       :      List[str]							=    in_sentvecs - np.mean(UpperCamelCase__						,     axis=0				)

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


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


     def 				_A       (				self       :	Union[str, Any]      ):
       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 				_A       (				self       :	Dict					, UpperCAmelCase_       :	List[str]					, UpperCAmelCase_       :	Tuple      ):
       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\"]"      )














from ..utils import DummyObject, requires_backends


class  SCREAMING_SNAKE_CASE			(			metaclass=lowerCAmelCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Union[str, Any]			=	['''keras_nlp''']


     def __init__(				self       :	Dict					, *UpperCAmelCase_       :	Optional[Any]					, **UpperCAmelCase_       :	Dict      ):
       requires_backends(self					, ["keras_nlp"]      )






