


'''simple docstring'''
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 					lowerCamelCase_ ( __UpperCamelCase					:       List[str]							,    __UpperCamelCase					:       List[Any]		)					->	Optional[int]:







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

def 					lowerCamelCase_ ( __UpperCamelCase					:       Any							,    __UpperCamelCase					:       Optional[int]		)					->	Optional[Any]:







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

def 					lowerCamelCase_ ( __UpperCamelCase					:       Tuple							,    __UpperCamelCase					:       int		)					->	List[Any]:







     """simple docstring"""
     _A				=							np.array(__UpperCamelCase		)
     _A				=							np.array(__UpperCamelCase		)
     _A				=							en_sentvecs.shape[0]

     # mean centering
     _A				=							en_sentvecs - np.mean(__UpperCamelCase							,    axis=0		)
     _A				=							in_sentvecs - np.mean(__UpperCamelCase							,    axis=0		)

     _A				=							cdist(__UpperCamelCase							,    __UpperCamelCase							,    'cosine'		)
     _A				=							np.array(range(__UpperCamelCase		)		)
     _A				=							sim.argsort(axis=1		)[:, :1_0]
     _A				=							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   UpperCamelCase						( self   )->      Dict:
            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			,     _UpperCamelCase			,     _UpperCamelCase   )->      Any:
            if self.config_name == "cvit-mkb-clsr":
                 return {"precision@10": precision_at_aa(_UpperCamelCase			,     _UpperCamelCase   )}
            elif self.config_name in ["wiki-ner"]:
                 return acc_and_fa(_UpperCamelCase			,     _UpperCamelCase   )
            elif self.config_name in [
                "wnli",
                "copa",
                "sna",
                "csqa",
                "wstp",
                "inltkh",
                "bbca",
                "iitp-mr",
                "iitp-pr",
                "actsa-sc",
                "md",
            ]:
                 return {"accuracy": simple_accuracy(_UpperCamelCase			,     _UpperCamelCase   )}
            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'''
def 					lowerCamelCase_ ( __UpperCamelCase					:       int		)					->	bool:







     """simple docstring"""
     return str(__UpperCamelCase		) == str(__UpperCamelCase		)[::-1]

def 					lowerCamelCase_ ( __UpperCamelCase					:       int		)					->	int:







     """simple docstring"""
     return int(__UpperCamelCase		) + int(str(__UpperCamelCase		)[::-1]		)

def 					lowerCamelCase_ ( __UpperCamelCase					:       int = 1_0_0_0_0		)					->	int:







     """simple docstring"""
     _A				=							[]
     for num in range(1							,    __UpperCamelCase		):
          _A				=							0
          _A				=							num
          while iterations < 5_0:
               _A				=							sum_reverse(__UpperCamelCase		)
               iterations += 1
               if is_palindrome(__UpperCamelCase		):
                    break
          else:
               lychrel_nums.append(__UpperCamelCase		)
     return len(__UpperCamelCase		)


if __name__ == "__main__":
    print(F'{solution() = }')





