'''simple docstring'''


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

import datasets


__snake_case						  =		"""\
    @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},
}
"""

__snake_case						  =		"""\
    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.
"""

__snake_case						  =		"""
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   A_      (       SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_						)			->List[str]:
  return float((preds == labels).mean()						)

def   A_      (       SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_						)			->Optional[int]:
  lowercase_     =       simple_accuracy(SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_						)
  lowercase_     =       float(fa_score(y_true=SCREAMING_SNAKE_CASE_ ,	y_pred=SCREAMING_SNAKE_CASE_						)						)
  return {
      "accuracy": acc,
      "f1": fa,
  }

def   A_      (       SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_						)			->Optional[Any]:
  lowercase_     =       np.array(SCREAMING_SNAKE_CASE_						)
  lowercase_     =       np.array(SCREAMING_SNAKE_CASE_						)
  lowercase_     =       en_sentvecs.shape[0]

  # mean centering
  lowercase_     =       en_sentvecs - np.mean(SCREAMING_SNAKE_CASE_ ,	axis=0						)
  lowercase_     =       in_sentvecs - np.mean(SCREAMING_SNAKE_CASE_ ,	axis=0						)

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


  """simple docstring"""

  def 		lowerCamelCase__  (		self      :       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 		lowerCamelCase__  (		self      :       Dict   ,				lowercase_      :       Optional[Any]   ,				lowercase_      :       List[str]      ):







    '''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 dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_torch_available, is_torch_tpu_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_torch_available():
       import torch

if is_torch_tpu_available(check_device=False):
       import torch_xla.core.xla_model as xm


__snake_case						  =		logging.get_logger(__name__)





@dataclass
class       _a    (		__a      ):


  """simple docstring"""

  A_    							=						[
      '''no_inference''',
      '''no_cuda''',
      '''no_tpu''',
      '''no_speed''',
      '''no_memory''',
      '''no_env_print''',
      '''no_multi_process''',
  ]




  def __init__(		self      :       int   ,				**lowercase_      :       int      ):







    '''simple docstring'''


    for deprecated_arg in self.deprecated_args:
      if deprecated_arg in kwargs:
        lowercase_     =       deprecated_arg[3:]
        setattr(self   ,				lowercase_   ,				not kwargs.pop(lowercase_      )      )
        logger.warning(
            F"""{deprecated_arg} is depreciated. Please use --no_{positive_arg} or"""
            F""" {positive_arg}={kwargs[positive_arg]}"""      )

    lowercase_     =       kwargs.pop("""torchscript"""   ,				self.torchscript      )
    lowercase_     =       kwargs.pop("""torch_xla_tpu_print_metrics"""   ,				self.torch_xla_tpu_print_metrics      )
    lowercase_     =       kwargs.pop("""fp16_opt_level"""   ,				self.fpaa_opt_level      )
    super().__init__(**lowercase_      )

  A_    							=						field(default=__a ,				metadata={'''help''': '''Trace the models using torchscript'''}      )
  A_    							=						field(default=__a ,				metadata={'''help''': '''Print Xla/PyTorch tpu metrics'''}      )
  A_    							=						field(
      default='''O1''' ,				metadata={
          '''help''': (
              '''For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\']. '''
              '''See details at https://nvidia.github.io/apex/amp.html'''
          )
      } ,				)




  @cached_property
  def 		lowerCamelCase__  (		self      :       Dict      ):







    '''simple docstring'''


    requires_backends(self   ,				["""torch"""]      )
    logger.info("""PyTorch: setting up devices"""      )
    if not self.cuda:
      lowercase_     =       torch.device("""cpu"""      )
      lowercase_     =       0
    elif is_torch_tpu_available():
      lowercase_     =       xm.xla_device()
      lowercase_     =       0
    else:
      lowercase_     =       torch.device("""cuda""" if torch.cuda.is_available() else """cpu"""      )
      lowercase_     =       torch.cuda.device_count()
    return device, n_gpu




  @property
  def 		lowerCamelCase__  (		self      :       List[str]      ):







    '''simple docstring'''


    return is_torch_tpu_available() and self.tpu




  @property
  def 		lowerCamelCase__  (		self      :       Tuple      ):







    '''simple docstring'''


    requires_backends(self   ,				["""torch"""]      )
    # TODO(PVP): currently only single GPU is supported
    return torch.cuda.current_device()




  @property
  def 		lowerCamelCase__  (		self      :       Dict      ):







    '''simple docstring'''


    requires_backends(self   ,				["""torch"""]      )
    return self._setup_devices[0]




  @property
  def 		lowerCamelCase__  (		self      :       Any      ):







    '''simple docstring'''


    requires_backends(self   ,				["""torch"""]      )
    return self._setup_devices[1]





  @property
  def 		lowerCamelCase__  (		self      :       Optional[int]      ):







    '''simple docstring'''


    return self.n_gpu > 0

