


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

import datasets


_UpperCAmelCase			:  Union[str, Any]     ="""\
    @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			:  Optional[Any]     ="""\
    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			:  Optional[int]     ="""
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 (		lowerCAmelCase_ ,   lowerCAmelCase_ )-> Tuple:
				return float((preds == labels).mean() )



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ )-> Union[str, Any]:
				lowerCAmelCase_ :      Any    				=				simple_accuracy(lowerCAmelCase_ ,   lowerCAmelCase_ )
				lowerCAmelCase_ :      Tuple    				=				float(fa_score(y_true=lowerCAmelCase_ ,   y_pred=lowerCAmelCase_ ) )
				return {
				    "accuracy": acc,
				    "f1": fa,
				}



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ )-> Optional[Any]:
				lowerCAmelCase_ :      Any    				=				np.array(lowerCAmelCase_ )
				lowerCAmelCase_ :      Tuple    				=				np.array(lowerCAmelCase_ )
				lowerCAmelCase_ :      Tuple    				=				en_sentvecs.shape[0]

				# mean centering
				lowerCAmelCase_ :      int    				=				en_sentvecs - np.mean(lowerCAmelCase_ ,   axis=0 )
				lowerCAmelCase_ :      Dict    				=				in_sentvecs - np.mean(lowerCAmelCase_ ,   axis=0 )

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







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







						'''simple docstring'''




						def 						lowercase_ (				self							)					->    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 						lowercase_ (				self   ,						__lowercase   ,						__lowercase							)					->    Union[str, 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"]'''							)



import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCAmelCase			:  str     =logging.get_logger(__name__)







class 				snake_case__(							UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__      :  Optional[int]					=							"""encoder-decoder"""
						SCREAMING_SNAKE_CASE__      :  str					=							True




						def __init__(				self   ,						**__lowercase							)					->    Union[str, Any]:
										super().__init__(**__lowercase							)
										assert (
										    "encoder" in kwargs and "decoder" in kwargs
										), "Config has to be initialized with encoder and decoder config"
										lowerCAmelCase_ :      str    				=				kwargs.pop('''encoder'''							)
										lowerCAmelCase_ :      int    				=				encoder_config.pop('''model_type'''							)
										lowerCAmelCase_ :      Optional[Any]    				=				kwargs.pop('''decoder'''							)
										lowerCAmelCase_ :      Optional[Any]    				=				decoder_config.pop('''model_type'''							)

										from ..auto.configuration_auto import AutoConfig

										lowerCAmelCase_ :      Union[str, Any]    				=				AutoConfig.for_model(__lowercase   ,						**__lowercase							)
										lowerCAmelCase_ :      List[str]    				=				AutoConfig.for_model(__lowercase   ,						**__lowercase							)
										lowerCAmelCase_ :      Any    				=				True




						@classmethod
						def 						lowercase_ (				cls   ,						__lowercase   ,						__lowercase   ,						**__lowercase							)					->    PretrainedConfig:
										logger.info('''Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'''							)
										lowerCAmelCase_ :      int    				=				True
										lowerCAmelCase_ :      List[Any]    				=				True

										return cls(encoder=encoder_config.to_dict()   ,						decoder=decoder_config.to_dict()   ,						**__lowercase							)




						def 						lowercase_ (				self							)					->    Any:
										lowerCAmelCase_ :      Optional[Any]    				=				copy.deepcopy(self.__dict__							)
										lowerCAmelCase_ :      List[str]    				=				self.encoder.to_dict()
										lowerCAmelCase_ :      Dict    				=				self.decoder.to_dict()
										lowerCAmelCase_ :      Optional[Any]    				=				self.__class__.model_type
										return output