



'''simple docstring'''





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

import datasets


__a          =		"\\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"

__a          =		"\\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"

__a          =		"\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 						__snake_case(				_lowerCAmelCase     ,   _lowerCAmelCase		)		-> List[Any]:
      return float((preds == labels).mean()		)





def 						__snake_case(				_lowerCAmelCase     ,   _lowerCAmelCase		)		-> Any:
      snake_case__  :    Any    						=      simple_accuracy(_lowerCAmelCase     ,   _lowerCAmelCase		)
      snake_case__  :    int    						=      float(fa_score(y_true=_lowerCAmelCase     ,   y_pred=_lowerCAmelCase		)		)
      return {
          "accuracy": acc,
          "f1": fa,
      }





def 						__snake_case(				_lowerCAmelCase     ,   _lowerCAmelCase		)		-> str:
      snake_case__  :    Dict    						=      np.array(_lowerCAmelCase		)
      snake_case__  :    Any    						=      np.array(_lowerCAmelCase		)
      snake_case__  :    Any    						=      en_sentvecs.shape[0]

      # mean centering
      snake_case__  :    Tuple    						=      en_sentvecs - np.mean(_lowerCAmelCase     ,   axis=0		)
      snake_case__  :    Dict    						=      in_sentvecs - np.mean(_lowerCAmelCase     ,   axis=0		)

      snake_case__  :    List[str]    						=      cdist(_lowerCAmelCase     ,   _lowerCAmelCase     ,   """cosine"""		)
      snake_case__  :    List[Any]    						=      np.array(range(_lowerCAmelCase		)		)
      snake_case__  :    Tuple    						=      sim.argsort(axis=1		)[:, :10]
      snake_case__  :    List[str]    						=      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 lowerCamelCase       (    self					:     str						):
          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					:     str ,     snake_case_					:     Dict ,     snake_case_					:     Optional[int]						):
          if self.config_name == "cvit-mkb-clsr":
                return {"precision@10": precision_at_aa(snake_case_ ,     snake_case_						)}
          elif self.config_name in ["wiki-ner"]:
                return acc_and_fa(snake_case_ ,     snake_case_						)
          elif self.config_name in [
              "wnli",
              "copa",
              "sna",
              "csqa",
              "wstp",
              "inltkh",
              "bbca",
              "iitp-mr",
              "iitp-pr",
              "actsa-sc",
              "md",
          ]:
                return {"accuracy": simple_accuracy(snake_case_ ,     snake_case_						)}
          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

from collections.abc import Callable
from typing import Generic, TypeVar

snake_case_			  = TypeVar('''T''')
snake_case_			  = TypeVar('''U''')


class       SCREAMING_SNAKE_CASE__					(Generic[T, U]     ):





    def __init__(      self						,   a						,   a):
         lowercase__    :   List[Any]      =       key
         lowercase__    :   List[Any]      =       val
         lowercase__    :   DoubleLinkedListNode[T, U] | None      =       None
         lowercase__    :   DoubleLinkedListNode[T, U] | None      =       None





    def __repr__(      self):
         return (
             f"""Node: key: {self.key}, val: {self.val}, """
             f"""has next: {bool(self.next)}, has prev: {bool(self.prev)}"""
         )



class       SCREAMING_SNAKE_CASE__					(Generic[T, U]     ):





    def __init__(      self):
         lowercase__    :   DoubleLinkedListNode[T, U]      =       DoubleLinkedListNode(a						,   a)
         lowercase__    :   DoubleLinkedListNode[T, U]      =       DoubleLinkedListNode(a						,   a)
         lowercase__      , lowercase__    :   Union[str, Any]      =       self.rear, self.head





    def __repr__(      self):
         lowercase__    :   Any      =       ['DoubleLinkedList']
         lowercase__    :   List[str]      =       self.head
         while node.next is not None:
              rep.append(str(a))
              lowercase__    :   Tuple      =       node.next
         rep.append(str(self.rear))
         return ",\n    ".join(a)





    def       snake_case_				(      self						,   a):
         lowercase__    :   Optional[Any]      =       self.rear.prev

         # All nodes other than self.head are guaranteed to have non-None previous
         assert previous is not None

         lowercase__    :   Dict      =       node
         lowercase__    :   int      =       previous
         lowercase__    :   Union[str, Any]      =       node
         lowercase__    :   Optional[int]      =       self.rear





    def       snake_case_				(      self						,   a):

         if node.prev is None or node.next is None:
              return None

         lowercase__    :   Union[str, Any]      =       node.next
         lowercase__    :   Tuple      =       node.prev
         lowercase__    :   Union[str, Any]      =       None
         lowercase__    :   List[Any]      =       None
         return node



class       SCREAMING_SNAKE_CASE__					(Generic[T, U]     ):
    __lowerCamelCase						:       dict[Callable[[T], U], LRUCache[T, U]]														=     {}





    def __init__(      self						,   a):
         lowercase__    :   DoubleLinkedList[T, U]      =       DoubleLinkedList()
         lowercase__    :   Optional[Any]      =       capacity
         lowercase__    :   Union[str, Any]      =       0
         lowercase__    :   Tuple      =       0
         lowercase__    :   int      =       0
         lowercase__    :   dict[T, DoubleLinkedListNode[T, U]]      =       {}





    def __repr__(      self):
         return (
             f"""CacheInfo(hits={self.hits}, misses={self.miss}, """
             f"""capacity={self.capacity}, current size={self.num_keys})"""
         )





    def __contains__(      self						,   a):
         return key in self.cache





    def       snake_case_				(      self						,   a):
         # Note: pythonic interface would throw KeyError rather than return None

         if key in self.cache:
              self.hits += 1
              lowercase__    :   DoubleLinkedListNode[T, U]      =       self.cache[key]
              lowercase__    :   str      =       self.list.remove(self.cache[key])
              assert node == value_node

              # node is guaranteed not None because it is in self.cache
              assert node is not None
              self.list.add(a)
              return node.val
         self.miss += 1
         return None





    def       snake_case_				(      self						,   a						,   a):

         if key not in self.cache:
              if self.num_keys >= self.capacity:
                   # delete first node (oldest) when over capacity
                   lowercase__    :   Optional[int]      =       self.list.head.next

                   # guaranteed to have a non-None first node when num_keys > 0
                   # explain to type checker via assertions
                   assert first_node is not None
                   assert first_node.key is not None
                   assert (
                       self.list.remove(a) is not None
                   )  # node guaranteed to be in list assert node.key is not None

                   del self.cache[first_node.key]
                   self.num_keys -= 1
              lowercase__    :   Optional[Any]      =       DoubleLinkedListNode(a						,   a)
              self.list.add(self.cache[key])
              self.num_keys += 1

         else:
              # bump node to the end of the list, update value
              lowercase__    :   Any      =       self.list.remove(self.cache[key])
              assert node is not None  # node guaranteed to be in list
              lowercase__    :   Union[str, Any]      =       value
              self.list.add(a)





    @classmethod
    def       snake_case_				(      cls						,   a = 128):

         def cache_decorator_inner(a) -> Callable[..., U]:
              def cache_decorator_wrapper(*a) -> U:
                   if func not in cls.decorator_function_to_instance_map:
                        lowercase__    :   Dict      =       LRUCache(a)

                   lowercase__    :   str      =       cls.decorator_function_to_instance_map[func].get(args[0])
                   if result is None:
                        lowercase__    :   str      =       func(*a)
                        cls.decorator_function_to_instance_map[func].put(args[0]						,   a)
                   return result

              def cache_info() -> LRUCache[T, U]:
                   return cls.decorator_function_to_instance_map[func]

              setattr(a						,   'cache_info'						,   a)  # noqa: B010

              return cache_decorator_wrapper

         return cache_decorator_inner


if __name__ == "__main__":
       import doctest

       doctest.testmod()

