



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 (       lowerCamelCase__					,			lowerCamelCase__						):

				"""simple docstring"""


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


def  __lowerCamelCase (       lowerCamelCase__					,			lowerCamelCase__						):

				"""simple docstring"""


				lowercase__					:   Tuple													=					simple_accuracy(lowerCamelCase__					,			lowerCamelCase__						)
				lowercase__					:   Optional[Any]													=					float(fa_score(y_true=lowerCamelCase__					,			y_pred=lowerCamelCase__						)						)
				return {
				    "accuracy": acc,
				    "f1": fa,
				}


def  __lowerCamelCase (       lowerCamelCase__					,			lowerCamelCase__						):

				"""simple docstring"""


				lowercase__					:   str													=					np.array(lowerCamelCase__						)
				lowercase__					:   Tuple													=					np.array(lowerCamelCase__						)
				lowercase__					:   List[str]													=					en_sentvecs.shape[0]

				# mean centering
				lowercase__					:   List[Any]													=					en_sentvecs - np.mean(lowerCamelCase__					,			axis=0						)
				lowercase__					:   int													=					in_sentvecs - np.mean(lowerCamelCase__					,			axis=0						)

				lowercase__					:   Dict													=					cdist(lowerCamelCase__					,			lowerCamelCase__					,			"cosine"						)
				lowercase__					:   Optional[int]													=					np.array(range(lowerCamelCase__						)						)
				lowercase__					:   Optional[Any]													=					sim.argsort(axis=1						)[:, :10]
				lowercase__					:   List[str]													=					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 			snake_case					(							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 			snake_case					(							self :     List[Any]				,       SCREAMING_SNAKE_CASE :     Any				,       SCREAMING_SNAKE_CASE :     Optional[Any]					):
									if self.config_name == "cvit-mkb-clsr":
													return {"precision@10": precision_at_aa(SCREAMING_SNAKE_CASE				,       SCREAMING_SNAKE_CASE					)}
									elif self.config_name in ["wiki-ner"]:
													return acc_and_fa(SCREAMING_SNAKE_CASE				,       SCREAMING_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(SCREAMING_SNAKE_CASE				,       SCREAMING_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\"]"					)









from typing import Union

import fire
import torch
from tqdm import tqdm


def  __lowerCamelCase (       lowerCamelCase__					,			lowerCamelCase__ = "cpu"					,			lowerCamelCase__ = None						):

				"""simple docstring"""


				lowercase__					:   Any													=					torch.load(lowerCamelCase__					,			map_location=lowerCamelCase__						)
				for k, v in tqdm(state_dict.items()						):
								if not isinstance(lowerCamelCase__					,			torch.Tensor						):
												raise TypeError("FP16 conversion only works on paths that are saved state dicts, like pytorch_model.bin"						)
								lowercase__					:   int													=					v.half()
				if save_path is None:  # overwrite src_path
								lowercase__					:   Optional[Any]													=					src_path
				torch.save(lowerCamelCase__					,			lowerCamelCase__						)


if __name__ == "__main__":
				fire.Fire(convert)




