






'''simple docstring'''



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

import datasets


__UpperCamelCase      :       List[Any]      			=      """\
    @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},
}
"""

__UpperCamelCase      :       Tuple      			=      """\
    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.
"""

__UpperCamelCase      :       Dict      			=      """
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    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Optional[int],					SCREAMING_SNAKE_CASE__:	Optional[int]    )  ->			Union[str, Any]:

   """simple docstring"""
   return float((preds == labels).mean()    )



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Optional[Any],					SCREAMING_SNAKE_CASE__:	Union[str, Any]    )  ->			List[Any]:

   """simple docstring"""
   __a				     =    simple_accuracy(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )
   __a				     =    float(fa_score(y_true=SCREAMING_SNAKE_CASE__,					y_pred=SCREAMING_SNAKE_CASE__    )    )
   return {
       "accuracy": acc,
       "f1": fa,
   }



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Optional[int],					SCREAMING_SNAKE_CASE__:	Optional[int]    )  ->			List[Any]:

   """simple docstring"""
   __a				     =    np.array(SCREAMING_SNAKE_CASE__    )
   __a				     =    np.array(SCREAMING_SNAKE_CASE__    )
   __a				     =    en_sentvecs.shape[0]

   # mean centering
   __a				     =    en_sentvecs - np.mean(SCREAMING_SNAKE_CASE__,					axis=0    )
   __a				     =    in_sentvecs - np.mean(SCREAMING_SNAKE_CASE__,					axis=0    )

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




      def  __UpperCamelCase							(  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  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase      )							->Optional[int]:



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







'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCamelCase      :       Tuple      			=      {
    """configuration_blip_2""": [
        """BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """Blip2Config""",
        """Blip2QFormerConfig""",
        """Blip2VisionConfig""",
    ],
    """processing_blip_2""": ["""Blip2Processor"""],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __UpperCamelCase      :       Optional[int]      			=      [
     """BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """Blip2Model""",
     """Blip2QFormerModel""",
     """Blip2PreTrainedModel""",
     """Blip2ForConditionalGeneration""",
     """Blip2VisionModel""",
 ]

if TYPE_CHECKING:
 from .configuration_blip_a import (
     BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP,
     BlipaConfig,
     BlipaQFormerConfig,
     BlipaVisionConfig,
 )
 from .processing_blip_a import BlipaProcessor

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_blip_a import (
      BLIP_2_PRETRAINED_MODEL_ARCHIVE_LIST,
      BlipaForConditionalGeneration,
      BlipaModel,
      BlipaPreTrainedModel,
      BlipaQFormerModel,
      BlipaVisionModel,
  )

else:
 import sys

 __UpperCamelCase      :       Dict      			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)