

'''simple docstring'''

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

import datasets


UpperCAmelCase					 =	'''\
    @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					 =	'''\
    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					 =	'''
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				(						lowercase__    :	Dict,       lowercase__    :	Optional[Any]			):






     '''simple docstring'''





     return float((preds == labels).mean()			)

def 					__UpperCamelCase				(						lowercase__    :	Dict,       lowercase__    :	Optional[Any]			):






     '''simple docstring'''





     __lowercase      		=simple_accuracy(lowercase__,       lowercase__			)
     __lowercase      		=float(fa_score(y_true=lowercase__,       y_pred=lowercase__			)			)
     return {
         "accuracy": acc,
         "f1": fa,
     }

def 					__UpperCamelCase				(						lowercase__    :	int,       lowercase__    :	List[Any]			):






     '''simple docstring'''





     __lowercase      		=np.array(lowercase__			)
     __lowercase      		=np.array(lowercase__			)
     __lowercase      		=en_sentvecs.shape[0]

     # mean centering
     __lowercase      		=en_sentvecs - np.mean(lowercase__,       axis=0			)
     __lowercase      		=in_sentvecs - np.mean(lowercase__,       axis=0			)

     __lowercase      		=cdist(lowercase__,       lowercase__,       'cosine'			)
     __lowercase      		=np.array(range(lowercase__			)			)
     __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 	lowerCAmelCase  (   datasets.Metric ):







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







            """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 typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


UpperCAmelCase					 =	{
    '''configuration_owlvit''': [
        '''OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''OwlViTConfig''',
        '''OwlViTOnnxConfig''',
        '''OwlViTTextConfig''',
        '''OwlViTVisionConfig''',
    ],
    '''processing_owlvit''': ['''OwlViTProcessor'''],
}


try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase					 =	['''OwlViTFeatureExtractor''']
       UpperCAmelCase					 =	['''OwlViTImageProcessor''']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase					 =	[
           '''OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''OwlViTModel''',
           '''OwlViTPreTrainedModel''',
           '''OwlViTTextModel''',
           '''OwlViTVisionModel''',
           '''OwlViTForObjectDetection''',
       ]

if TYPE_CHECKING:
       from .configuration_owlvit import (
           OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP,
           OwlViTConfig,
           OwlViTOnnxConfig,
           OwlViTTextConfig,
           OwlViTVisionConfig,
       )
       from .processing_owlvit import OwlViTProcessor

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_owlvit import OwlViTFeatureExtractor
              from .image_processing_owlvit import OwlViTImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_owlvit import (
                  OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  OwlViTForObjectDetection,
                  OwlViTModel,
                  OwlViTPreTrainedModel,
                  OwlViTTextModel,
                  OwlViTVisionModel,
              )

else:
       import sys

       UpperCAmelCase					 =	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


