






"""simple docstring"""



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

import datasets


__A		:       Tuple  				=		'''\
    @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},
}
'''

__A		:       Dict  				=		'''\
    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.
'''

__A		:       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 						lowercase    (				__snake_case				: List[str]		,					__snake_case				: Union[str, Any]	):
		return float((preds == labels).mean()	)



def 						lowercase    (				__snake_case				: Dict		,					__snake_case				: str	):
		lowercase_ : int							       =   simple_accuracy(_lowerCamelCase		,					_lowerCamelCase	)
		lowercase_ : Optional[Any]							       =   float(fa_score(y_true=_lowerCamelCase		,					y_pred=_lowerCamelCase	)	)
		return {
		    "accuracy": acc,
		    "f1": fa,
		}



def 						lowercase    (				__snake_case				: Optional[Any]		,					__snake_case				: Any	):
		lowercase_ : int							       =   np.array(_lowerCamelCase	)
		lowercase_ : List[Any]							       =   np.array(_lowerCamelCase	)
		lowercase_ : Dict							       =   en_sentvecs.shape[0]

		# mean centering
		lowercase_ : int							       =   en_sentvecs - np.mean(_lowerCamelCase		,					axis=0	)
		lowercase_ : List[Any]							       =   in_sentvecs - np.mean(_lowerCamelCase		,					axis=0	)

		lowercase_ : Union[str, Any]							       =   cdist(_lowerCamelCase		,					_lowerCamelCase		,					'''cosine'''	)
		lowercase_ : str							       =   np.array(range(_lowerCamelCase	)	)
		lowercase_ : Optional[int]							       =   sim.argsort(axis=1	)[:, :1_0]
		lowercase_ : Any							       =   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							):




					def   A  (				self     :						Any   )  ->  Tuple:
							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    ,						A     :						List[Any]    ,						A     :						Tuple   )  ->  List[Any]:
							if self.config_name == "cvit-mkb-clsr":
									return {"precision@10": precision_at_aa(lowercase_    ,						lowercase_   )}
							elif self.config_name in ["wiki-ner"]:
									return acc_and_fa(lowercase_    ,						lowercase_   )
							elif self.config_name in [
							    "wnli",
							    "copa",
							    "sna",
							    "csqa",
							    "wstp",
							    "inltkh",
							    "bbca",
							    "iitp-mr",
							    "iitp-pr",
							    "actsa-sc",
							    "md",
							]:
									return {"accuracy": simple_accuracy(lowercase_    ,						lowercase_   )}
							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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


UpperCamelCase  							=						{}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase  							=						['''GPTSw3Tokenizer''']


if TYPE_CHECKING:
      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_gpt_swa import GPTSwaTokenizer

else:
      import sys

      UpperCamelCase  							=						_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



