




"""simple docstring"""






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

import datasets


UpperCamelCase__						=			'''\
    @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},
}
'''

UpperCamelCase__						=			'''\
    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.
'''

UpperCamelCase__						=			'''
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		(		snake_case			:					str      ,       snake_case			:					Union[str, Any]    ):
					return float((preds == labels).mean()    )





def 							UpperCAmelCase		(		snake_case			:					int      ,       snake_case			:					str    ):
					_lowerCAmelCase:int									=  simple_accuracy(snake_case      ,       snake_case    )
					_lowerCAmelCase:Optional[int]									=  float(fa_score(y_true=snake_case      ,       y_pred=snake_case    )    )
					return {
					    "accuracy": acc,
					    "f1": fa,
					}





def 							UpperCAmelCase		(		snake_case			:					int      ,       snake_case			:					Tuple    ):
					_lowerCAmelCase:Union[str, Any]									=  np.array(snake_case    )
					_lowerCAmelCase:str									=  np.array(snake_case    )
					_lowerCAmelCase:Union[str, Any]									=  en_sentvecs.shape[0]

					# mean centering
					_lowerCAmelCase:Optional[int]									=  en_sentvecs - np.mean(snake_case      ,       axis=0    )
					_lowerCAmelCase:List[str]									=  in_sentvecs - np.mean(snake_case      ,       axis=0    )

					_lowerCAmelCase:int									=  cdist(snake_case      ,       snake_case      ,       '''cosine'''    )
					_lowerCAmelCase:List[Any]									=  np.array(range(snake_case    )    )
					_lowerCAmelCase:str									=  sim.argsort(axis=1    )[:, :10]
					_lowerCAmelCase:Tuple									=  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       __UpperCamelCase     (							self      :	Optional[Any])						->       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       __UpperCamelCase     (							self      :	Dict     ,a__      :	Any     ,a__      :	Dict)						->       Tuple:




											"""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"]''')












"""simple docstring"""






def 							UpperCAmelCase		(		snake_case			:					int      ,       snake_case			:					int    ):
					return x if y == 0 else greatest_common_divisor(snake_case      ,       x % y    )





def 							UpperCAmelCase		(		snake_case			:					int      ,       snake_case			:					int    ):
					return (x * y) // greatest_common_divisor(snake_case      ,       snake_case    )





def 							UpperCAmelCase		(		snake_case			:					int = 20    ):
					_lowerCAmelCase:List[Any]									=  1
					for i in range(1      ,       n + 1    ):
										_lowerCAmelCase:List[str]									=  lcm(snake_case      ,       snake_case    )
					return g


if __name__ == "__main__":
				print(F"{solution() = }")






