



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





'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__a          =		{
    "configuration_bloom": ["BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP", "BloomConfig", "BloomOnnxConfig"],
}
try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __a          =		["BloomTokenizerFast"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __a          =		[
           "BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST",
           "BloomForCausalLM",
           "BloomModel",
           "BloomPreTrainedModel",
           "BloomForSequenceClassification",
           "BloomForTokenClassification",
           "BloomForQuestionAnswering",
       ]

if TYPE_CHECKING:
       from .configuration_bloom import BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP, BloomConfig, BloomOnnxConfig

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_bloom_fast import BloomTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_bloom import (
                  BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST,
                  BloomForCausalLM,
                  BloomForQuestionAnswering,
                  BloomForSequenceClassification,
                  BloomForTokenClassification,
                  BloomModel,
                  BloomPreTrainedModel,
              )

else:
       import sys

       __a          =		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
