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

import datasets


UpperCAmelCase__		:     str     			=      '\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n'

UpperCAmelCase__		:     Dict     			=      '\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n'

UpperCAmelCase__		:     List[Any]     			=      '\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for \'cvit-mkb-clsr\' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for \'cvit-mkb-clsr\' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    "accuracy": Accuracy\n    "f1": F1 score\n    "precision": Precision@10\nExamples:\n\n    >>> 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"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wiki-ner\')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0, \'f1\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'cvit-mkb-clsr\')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'precision@10\': 1.0}\n\n'






def   lowerCamelCase__							(					a		,		a      )      ->   List[str]:
   return float((preds == labels).mean()      )






def   lowerCamelCase__							(					a		,		a      )      ->   List[str]:
   _A:  Union[str, Any]					=       simple_accuracy(a		,		a      )
   _A:  Union[str, Any]					=       float(fa_score(y_true=a		,		y_pred=a      )      )
   return {
       "accuracy": acc,
       "f1": fa,
   }






def   lowerCamelCase__							(					a		,		a      )      ->   str:
   _A:  Any					=       np.array(a      )
   _A:  int					=       np.array(a      )
   _A:  List[str]					=       en_sentvecs.shape[0]

   # mean centering
   _A:  Optional[Any]					=       en_sentvecs - np.mean(a		,		axis=0      )
   _A:  Optional[int]					=       in_sentvecs - np.mean(a		,		axis=0      )

   _A:  Tuple					=       cdist(a		,		a		,		'''cosine'''      )
   _A:  List[Any]					=       np.array(range(a      )      )
   _A:  List[Any]					=       sim.argsort(axis=1      )[:, :10]
   _A:  Tuple					=       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   ):





   '''simple docstring'''


   def  __magic_name__				(					self     :							str     ):

      """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  __magic_name__				(					self     :							int			,			lowerCAmelCase_     :							str			,			lowerCAmelCase_     :							Union[str, Any]     ):

      """simple docstring"""
      if self.config_name == "cvit-mkb-clsr":
         return {"precision@10": precision_at_aa(lowerCAmelCase_			,			lowerCAmelCase_     )}
      elif self.config_name in ["wiki-ner"]:
         return acc_and_fa(lowerCAmelCase_			,			lowerCAmelCase_     )
      elif self.config_name in [
          "wnli",
          "copa",
          "sna",
          "csqa",
          "wstp",
          "inltkh",
          "bbca",
          "iitp-mr",
          "iitp-pr",
          "actsa-sc",
          "md",
      ]:
         return {"accuracy": simple_accuracy(lowerCAmelCase_			,			lowerCAmelCase_     )}
      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 __future__ import annotations

import sys
from collections import deque
from typing import Generic, TypeVar

UpperCAmelCase__		:     Union[str, Any]     			=      TypeVar('T')






class UpperCAmelCase   (						Generic[T]   ):





   '''simple docstring'''
   __UpperCamelCase		:    deque[T]  # Cache store of keys
   __UpperCamelCase		:    set[T]  # References of the keys in cache
   __UpperCamelCase		:    int 				=    10  # Maximum capacity of cache


   def __init__(					self     :							List[str]			,			lowerCAmelCase_     :							int     ):

      """simple docstring"""
      _A:  Tuple					=       deque()
      _A:  List[Any]					=       set()
      if not n:
         _A:  str					=       sys.maxsize
      elif n < 0:
         raise ValueError('''n should be an integer greater than 0.'''     )
      else:
         _A:  Dict					=       n


   def  __magic_name__				(					self     :							Optional[int]			,			lowerCAmelCase_     :							T     ):

      """simple docstring"""
      if x not in self.key_reference:
         if len(self.dq_store     ) == LRUCache._MAX_CAPACITY:
            _A:  Optional[Any]					=       self.dq_store.pop()
            self.key_reference.remove(lowerCAmelCase_     )
      else:
         self.dq_store.remove(lowerCAmelCase_     )

      self.dq_store.appendleft(lowerCAmelCase_     )
      self.key_reference.add(lowerCAmelCase_     )


   def  __magic_name__				(					self     :							Optional[Any]     ):

      """simple docstring"""
      for k in self.dq_store:
         print(lowerCAmelCase_     )


   def __repr__(					self     :							Dict     ):

      """simple docstring"""
      return F"""LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store     )}"""


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   UpperCAmelCase__		:     LRUCache[str | int]     			=      LRUCache(4)
   lru_cache.refer('A')
   lru_cache.refer(2)
   lru_cache.refer(3)
   lru_cache.refer('A')
   lru_cache.refer(4)
   lru_cache.refer(5)
   lru_cache.display()

   print(lru_cache)
   assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"



