






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

import datasets


lowerCamelCase__       		=  """\
    @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},
}
"""

lowerCamelCase__       		=  """\
    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.
"""

lowerCamelCase__       		=  """
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	(							snake_case__  : List[Any]						,snake_case__  : str	):




     '''simple docstring'''






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






def 	UpperCamelCase	(							snake_case__  : Optional[int]						,snake_case__  : str	):




     '''simple docstring'''






     __snake_case      :str 							=    simple_accuracy(__snake_case						,__snake_case	)
     __snake_case      :Union[str, Any] 							=    float(fa_score(y_true=__snake_case						,y_pred=__snake_case	)	)
     return {
         "accuracy": acc,
         "f1": fa,
     }






def 	UpperCamelCase	(							snake_case__  : Optional[Any]						,snake_case__  : Tuple	):




     '''simple docstring'''






     __snake_case      :Dict 							=    np.array(__snake_case	)
     __snake_case      :Optional[Any] 							=    np.array(__snake_case	)
     __snake_case      :List[Any] 							=    en_sentvecs.shape[0]

     # mean centering
     __snake_case      :str 							=    en_sentvecs - np.mean(__snake_case						,axis=0	)
     __snake_case      :Optional[int] 							=    in_sentvecs - np.mean(__snake_case						,axis=0	)

     __snake_case      :Union[str, Any] 							=    cdist(__snake_case						,__snake_case						,"""cosine"""	)
     __snake_case      :str 							=    np.array(range(__snake_case	)	)
     __snake_case      :Optional[Any] 							=    sim.argsort(axis=1	)[:, :10]
     __snake_case      :Dict 							=    np.any(preds == actual[:, None]						,axis=1	)
     return float(matches.mean()	)




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,     _KWARGS_DESCRIPTION)
class       snake_case__ (				datasets.Metric):

       '''simple docstring'''



       def        __lowercase    (				self     )			->   Tuple:






            '''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        __lowercase    (				self      ,    a__      ,    a__     )			->   Any:






            '''simple docstring'''





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

from ...utils import logging
from .image_processing_imagegpt import ImageGPTImageProcessor


UpperCAmelCase				=						logging.get_logger(__name__)




class 	lowercase__				(					A_				):





   def __init__(							self      ,   *SCREAMING_SNAKE_CASE      ,   **SCREAMING_SNAKE_CASE)  ->  None:
      warnings.warn(
          """The class ImageGPTFeatureExtractor is deprecated and will be removed in version 5 of Transformers."""
          """ Please use ImageGPTImageProcessor instead."""      ,   SCREAMING_SNAKE_CASE      ,   )
      super().__init__(*SCREAMING_SNAKE_CASE      ,   **SCREAMING_SNAKE_CASE)

