






'''simple docstring'''


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

import datasets


lowerCamelCase_				: List[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},
}
'''

lowerCamelCase_				: List[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.
'''

lowerCamelCase_				: List[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 	__magic_name__( _A						,      _A					):
						'''simple docstring'''





						return float((preds == labels).mean()					)







def 	__magic_name__( _A						,      _A					):
						'''simple docstring'''





						UpperCamelCase__         = simple_accuracy(_A						,      _A					)
						UpperCamelCase__         = float(fa_score(y_true=_A						,      y_pred=_A					)					)
						return {
						    "accuracy": acc,
						    "f1": fa,
						}







def 	__magic_name__( _A						,      _A					):
						'''simple docstring'''





						UpperCamelCase__         = np.array(_A					)
						UpperCamelCase__         = np.array(_A					)
						UpperCamelCase__         = en_sentvecs.shape[0]

						# mean centering
						UpperCamelCase__         = en_sentvecs - np.mean(_A						,      axis=0					)
						UpperCamelCase__         = in_sentvecs - np.mean(_A						,      axis=0					)

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


			'''simple docstring'''





			def 				A      (   self							:						str			)							->    List[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 				A      (   self							:						Union[str, Any] ,      lowercase							:						int ,      lowercase							:						Dict			)							->    Tuple:

									'''simple docstring'''







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








'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


lowerCamelCase_				: Tuple    	=							{
    '''configuration_layoutlmv3''': [
        '''LAYOUTLMV3_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''LayoutLMv3Config''',
        '''LayoutLMv3OnnxConfig''',
    ],
    '''processing_layoutlmv3''': ['''LayoutLMv3Processor'''],
    '''tokenization_layoutlmv3''': ['''LayoutLMv3Tokenizer'''],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_				: Tuple    	=							['''LayoutLMv3TokenizerFast''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_				: Union[str, Any]    	=							[
					    '''LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''LayoutLMv3ForQuestionAnswering''',
					    '''LayoutLMv3ForSequenceClassification''',
					    '''LayoutLMv3ForTokenClassification''',
					    '''LayoutLMv3Model''',
					    '''LayoutLMv3PreTrainedModel''',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_				: Optional[Any]    	=							[
					    '''TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TFLayoutLMv3ForQuestionAnswering''',
					    '''TFLayoutLMv3ForSequenceClassification''',
					    '''TFLayoutLMv3ForTokenClassification''',
					    '''TFLayoutLMv3Model''',
					    '''TFLayoutLMv3PreTrainedModel''',
					]

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_				: Optional[Any]    	=							['''LayoutLMv3FeatureExtractor''']
					lowerCamelCase_				: Dict    	=							['''LayoutLMv3ImageProcessor''']


if TYPE_CHECKING:
					from .configuration_layoutlmva import (
					    LAYOUTLMV3_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    LayoutLMvaConfig,
					    LayoutLMvaOnnxConfig,
					)
					from .processing_layoutlmva import LayoutLMvaProcessor
					from .tokenization_layoutlmva import LayoutLMvaTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_layoutlmva import (
										    LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
										    LayoutLMvaForQuestionAnswering,
										    LayoutLMvaForSequenceClassification,
										    LayoutLMvaForTokenClassification,
										    LayoutLMvaModel,
										    LayoutLMvaPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_layoutlmva import (
										    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFLayoutLMvaForQuestionAnswering,
										    TFLayoutLMvaForSequenceClassification,
										    TFLayoutLMvaForTokenClassification,
										    TFLayoutLMvaModel,
										    TFLayoutLMvaPreTrainedModel,
										)

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor
										from .image_processing_layoutlmva import LayoutLMvaImageProcessor

else:
					import sys

					lowerCamelCase_				: Optional[Any]    	=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
