






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

import datasets


lowercase  :							str			  =    '''\
    @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  :							Optional[int]			  =    '''\
    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  :							Optional[Any]			  =    '''
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__	(    _a       :			int  ,      _a       :			Optional[int]    ):
		return float((preds == labels).mean()    )

def      lowerCAmelCase__	(    _a       :			Union[str, Any]  ,      _a       :			Tuple    ):
		snake_case_				:							List[Any]						 =       simple_accuracy(_a  ,      _a    )
		snake_case_				:							List[str]						 =       float(fa_score(y_true=_a  ,      y_pred=_a    )    )
		return {
		    "accuracy": acc,
		    "f1": fa,
		}

def      lowerCAmelCase__	(    _a       :			Union[str, Any]  ,      _a       :			Union[str, Any]    ):
		snake_case_				:							List[str]						 =       np.array(_a    )
		snake_case_				:							List[str]						 =       np.array(_a    )
		snake_case_				:							str						 =       en_sentvecs.shape[0]

		# mean centering
		snake_case_				:							Tuple						 =       en_sentvecs - np.mean(_a  ,      axis=0    )
		snake_case_				:							str						 =       in_sentvecs - np.mean(_a  ,      axis=0    )

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




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


						'''simple docstring'''




						def       _lowerCAmelCase       (	self				) ->				int:
								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		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				) ->				str:
								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\"]"				)








def      lowerCAmelCase__	(    _a       :			int    ):
		if num < 0:
				return False

		snake_case_				:							int						 =       num
		snake_case_				:							int						 =       0
		while num > 0:
				snake_case_				:							Union[str, Any]						 =       rev_num * 10 + (num % 10)
				num //= 10

		return num_copy == rev_num


if __name__ == "__main__":
							import doctest

							doctest.testmod()
