





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

import datasets


lowercase_          =		"""\
    @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},
}
"""

lowercase_          =		"""\
    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.
"""

lowercase_          =		"""
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       __UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       str:
  return float((preds == labels).mean()		)




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       Optional[Any]:
  lowercase__           =  simple_accuracy(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)
  lowercase__           =  float(fa_score(y_true=_SCREAMING_SNAKE_CASE		,						y_pred=_SCREAMING_SNAKE_CASE		)		)
  return {
      "accuracy": acc,
      "f1": fa,
  }




def       __UpperCamelCase  (_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		)    ->       int:
  lowercase__           =  np.array(_SCREAMING_SNAKE_CASE		)
  lowercase__           =  np.array(_SCREAMING_SNAKE_CASE		)
  lowercase__           =  en_sentvecs.shape[0]

  # mean centering
  lowercase__           =  en_sentvecs - np.mean(_SCREAMING_SNAKE_CASE		,						axis=0		)
  lowercase__           =  in_sentvecs - np.mean(_SCREAMING_SNAKE_CASE		,						axis=0		)

  lowercase__           =  cdist(_SCREAMING_SNAKE_CASE		,						_SCREAMING_SNAKE_CASE		,						'cosine'		)
  lowercase__           =  np.array(range(_SCREAMING_SNAKE_CASE		)		)
  lowercase__           =  sim.argsort(axis=1		)[:, :10]
  lowercase__           =  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				):


   def 	SCREAMING_SNAKE_CASE_							(   self      :    Dict	)->       Optional[Any]:





     """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 	SCREAMING_SNAKE_CASE_							(   self      :    Tuple      ,					a      :    List[Any]      ,					a      :    List[Any]	)->       Optional[Any]:





     """simple docstring"""







     if self.config_name == "cvit-mkb-clsr":
       return {"precision@10": precision_at_aa(a      ,					a	)}
     elif self.config_name in ["wiki-ner"]:
       return acc_and_fa(a      ,					a	)
     elif self.config_name in [
         "wnli",
         "copa",
         "sna",
         "csqa",
         "wstp",
         "inltkh",
         "bbca",
         "iitp-mr",
         "iitp-pr",
         "actsa-sc",
         "md",
     ]:
       return {"accuracy": simple_accuracy(a      ,					a	)}
     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 dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Value
from .base import TaskTemplate
@dataclass(frozen=UpperCAmelCase				)
class     SCREAMING_SNAKE_CASE       (UpperCAmelCase				):
   _UpperCamelCase   :		str			 =	field(default='language-modeling'      ,     metadata={'include_in_asdict_even_if_is_default': True}				)

   _UpperCamelCase   :		ClassVar[Features]			 =	Features({'text': Value('string'				)}				)
   _UpperCamelCase   :		ClassVar[Features]			 =	Features({}				)
   _UpperCamelCase   :		str			 =	"text"


   @property
   def 	SCREAMING_SNAKE_CASE_							(   self      :    List[str]	)->       Dict[str, str]:





     """simple docstring"""







     return {self.text_column: "text"}


