

'''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 							_lowerCAmelCase (      __magic_name__	:    int      ,   __magic_name__	:    Optional[int]	)							->     Optional[int]:
						return float((preds == labels).mean()	)






def 							_lowerCAmelCase (      __magic_name__	:    Union[str, Any]      ,   __magic_name__	:    Tuple	)							->     Tuple:
						lowercase   :       List[Any]								=simple_accuracy(__magic_name__      ,   __magic_name__	)
						lowercase   :       List[str]								=float(fa_score(y_true=__magic_name__      ,   y_pred=__magic_name__	)	)
						return {
						    "accuracy": acc,
						    "f1": fa,
						}






def 							_lowerCAmelCase (      __magic_name__	:    Union[str, Any]      ,   __magic_name__	:    Union[str, Any]	)							->     int:
						lowercase   :       List[str]								=np.array(__magic_name__	)
						lowercase   :       List[str]								=np.array(__magic_name__	)
						lowercase   :       str								=en_sentvecs.shape[0]

						# mean centering
						lowercase   :       Tuple								=en_sentvecs - np.mean(__magic_name__      ,   axis=0	)
						lowercase   :       str								=in_sentvecs - np.mean(__magic_name__      ,   axis=0	)

						lowercase   :       str								=cdist(__magic_name__      ,   __magic_name__      ,   '''cosine'''	)
						lowercase   :       List[str]								=np.array(range(__magic_name__	)	)
						lowercase   :       Dict								=sim.argsort(axis=1	)[:, :10]
						lowercase   :       Optional[int]								=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    lowerCamelCase_  (					self    :		Optional[int]      ):
										'''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    lowerCamelCase_  (					self    :		Optional[Any]		,				UpperCAmelCase__    :		Any		,				UpperCAmelCase__    :		Optional[Any]      ):
										'''simple docstring'''
										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'''





from __future__ import annotations






def 							_lowerCAmelCase (      __magic_name__	:    list[list[int]]	)							->     bool:
						lowercase   :       str								=len(__magic_name__	)
						# We need to create solution object to save path.
						lowercase   :       int								=[[0 for _ in range(__magic_name__	)] for _ in range(__magic_name__	)]
						lowercase   :       List[Any]								=run_maze(__magic_name__      ,   0      ,   0      ,   __magic_name__	)
						if solved:
												print('''\n'''.join(str(__magic_name__	) for row in solutions	)	)
						else:
												print('''No solution exists!'''	)
						return solved






def 							_lowerCAmelCase (      __magic_name__	:    list[list[int]]      ,   __magic_name__	:    int      ,   __magic_name__	:    int      ,   __magic_name__	:    list[list[int]]	)							->     bool:
						lowercase   :       Optional[int]								=len(__magic_name__	)
						# Final check point.
						if i == j == (size - 1):
												lowercase   :       Optional[int]								=1
												return True

						lowercase   :       Optional[int]								=(not i < 0) and (not j < 0)  # Check lower bounds
						lowercase   :       Tuple								=(i < size) and (j < size)  # Check upper bounds

						if lower_flag and upper_flag:
												# check for already visited and block points.
												lowercase   :       Union[str, Any]								=(not solutions[i][j]) and (not maze[i][j])
												if block_flag:
																		# check visited
																		lowercase   :       Union[str, Any]								=1

																		# check for directions
																		if (
																		    run_maze(__magic_name__      ,   i + 1      ,   __magic_name__      ,   __magic_name__	)
																		    or run_maze(__magic_name__      ,   __magic_name__      ,   j + 1      ,   __magic_name__	)
																		    or run_maze(__magic_name__      ,   i - 1      ,   __magic_name__      ,   __magic_name__	)
																		    or run_maze(__magic_name__      ,   __magic_name__      ,   j - 1      ,   __magic_name__	)
																		):
																								return True

																		lowercase   :       str								=0
																		return False
						return False


if __name__ == "__main__":
							import doctest

							doctest.testmod()





