




'''simple docstring'''

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

import datasets


a       :						List[Any]								=		'''\
    @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},
}
'''

a       :						Union[str, Any]								=		'''\
    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.
'''

a       :						str								=		'''
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	(   _UpperCAmelCase		:   List[str]		,				_UpperCAmelCase		:   str						)      ->      Tuple:
			return float((preds == labels).mean()						)


def __UpperCAmelCase	(   _UpperCAmelCase		:   Dict		,				_UpperCAmelCase		:   List[str]						)      ->      int:
			__snake_case			=		simple_accuracy(_UpperCAmelCase		,				_UpperCAmelCase						)
			__snake_case			=		float(fa_score(y_true=_UpperCAmelCase		,				y_pred=_UpperCAmelCase						)						)
			return {
			    "accuracy": acc,
			    "f1": fa,
			}


def __UpperCAmelCase	(   _UpperCAmelCase		:   List[str]		,				_UpperCAmelCase		:   str						)      ->      Union[str, Any]:
			__snake_case			=		np.array(_UpperCAmelCase						)
			__snake_case			=		np.array(_UpperCAmelCase						)
			__snake_case			=		en_sentvecs.shape[0]

			# mean centering
			__snake_case			=		en_sentvecs - np.mean(_UpperCAmelCase		,				axis=0						)
			__snake_case			=		in_sentvecs - np.mean(_UpperCAmelCase		,				axis=0						)

			__snake_case			=		cdist(_UpperCAmelCase		,				_UpperCAmelCase		,				"cosine"						)
			__snake_case			=		np.array(range(_UpperCAmelCase						)						)
			__snake_case			=		sim.argsort(axis=1						)[:, :10]
			__snake_case			=		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 							A (      self						:    Optional[Any]							):



						"""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 							A (      self						:    str      ,		a_						:    Any      ,		a_						:    Optional[int]							):



						"""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 random
import unittest

import numpy as np

import transformers
from transformers import is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax


if is_flax_available():
		import os

		import jax.numpy as jnp
		from jax import jit

		from transformers import AutoTokenizer, FlaxAutoModelForCausalLM
		from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model

		UpperCamelCase_       :    List[Any]						      =			'''0.12'''  # assumed parallelism: 8


if is_torch_available():
		import torch
def 				A_  (__a					, __a					, __a=None					):

					'''simple docstring'''





					if rng is None:
										A_								=    random.Random()

					A_								=    1
					for dim in shape:
										total_dims *= dim

					A_								=    []
					for _ in range(__a					):
										values.append(rng.randint(0					, vocab_size - 1					)					)

					A_								=    np.array(__a					, dtype=jnp.intaa					).reshape(__a					)

					return output
def 				A_  (__a					, __a=None					):

					'''simple docstring'''





					A_								=    ids_tensor(__a					, vocab_size=2					, rng=__a					)
					# make sure that at least one token is attended to for each batch
					A_								=    1
					return attn_mask



@require_flax
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					None
			snake_case						   =					()




			def   lowerCamelCase__  (					self    :       Any						)   ->			Tuple:







								"""simple docstring"""
								A_			,     A_								=    self.model_tester.prepare_config_and_inputs_for_common()

								# cut to half length & take max batch_size 3
								A_								=    2
								A_								=    inputs["input_ids"].shape[-1] // 2
								A_								=    inputs["input_ids"][:max_batch_size, :sequence_length]

								A_								=    jnp.ones_like(_snake_case						)
								A_								=    attention_mask[:max_batch_size, :sequence_length]

								# generate max 5 tokens
								A_								=    input_ids.shape[-1] + 5
								if config.eos_token_id is not None and config.pad_token_id is None:
													# hack to allow generate for models such as GPT2 as is done in `generate()`
													A_								=    config.eos_token_id
								return config, input_ids, attention_mask, max_length




			@is_pt_flax_cross_test
			def   lowerCamelCase__  (					self    :       List[Any]						)   ->			List[Any]:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    False
								A_								=    max_length
								A_								=    0

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model_class.__name__[4:]  # Skip the "Flax" at the beginning
													A_								=    getattr(_snake_case							, _snake_case						)
													A_								=    pt_model_class(_snake_case						).eval()
													A_								=    load_flax_weights_in_pytorch_model(_snake_case							, flax_model.params						)

													A_								=    flax_model.generate(_snake_case						).sequences
													A_								=    pt_model.generate(torch.tensor(_snake_case							, dtype=torch.long						)						)

													if flax_generation_outputs.shape[-1] > pt_generation_outputs.shape[-1]:
																		A_								=    flax_generation_outputs[:, : pt_generation_outputs.shape[-1]]

													self.assertListEqual(pt_generation_outputs.numpy().tolist()							, flax_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       Any						)   ->			Optional[Any]:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    False
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       Tuple						)   ->			List[str]:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    True
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       Tuple						)   ->			Dict:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    False
								A_								=    max_length
								A_								=    2

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       str						)   ->			Union[str, Any]:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    False
								A_								=    max_length
								A_								=    2
								A_								=    2

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[0]							, input_ids.shape[0] * config.num_return_sequences						)




			def   lowerCamelCase__  (					self    :       Union[str, Any]						)   ->			Dict:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    True
								A_								=    max_length
								A_								=    0.8
								A_								=    10
								A_								=    0.3
								A_								=    1
								A_								=    8
								A_								=    9

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       List[str]						)   ->			Any:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    max_length
								A_								=    1
								A_								=    8
								A_								=    9

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       Optional[Any]						)   ->			Dict:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    max_length
								A_								=    2
								A_								=    1
								A_								=    8
								A_								=    9

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       Tuple						)   ->			Any:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()

								# pad attention mask on the left
								A_								=    attention_mask.at[(0, 0)].set(0						)

								A_								=    False
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case							, attention_mask=_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case							, attention_mask=_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       List[str]						)   ->			int:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()

								# pad attention mask on the left
								A_								=    attention_mask.at[(0, 0)].set(0						)

								A_								=    True
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case							, attention_mask=_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case							, attention_mask=_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)






			def   lowerCamelCase__  (					self    :       Dict						)   ->			int:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()

								# pad attention mask on the left
								A_								=    attention_mask.at[(0, 0)].set(0						)

								A_								=    2
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case							, attention_mask=_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case							, attention_mask=_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)





@require_flax
class __lowerCAmelCase					(       unittest.TestCase   ):




			"""simple docstring"""







			def   lowerCamelCase__  (					self    :       Optional[Any]						)   ->			Any:







								"""simple docstring"""
								A_								=    AutoTokenizer.from_pretrained("hf-internal-testing/tiny-bert"						)
								A_								=    FlaxAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-bert-flax-only"						)

								A_								=    "Hello world"
								A_								=    tokenizer(_snake_case							, return_tensors="np"						).input_ids

								# typos are quickly detected (the correct argument is `do_sample`)
								with self.assertRaisesRegex(_snake_case							, "do_samples"						):
													model.generate(_snake_case							, do_samples=_snake_case						)

								# arbitrary arguments that will not be used anywhere are also not accepted
								with self.assertRaisesRegex(_snake_case							, "foo"						):
													A_								=    {"foo": "bar"}
													model.generate(_snake_case							, **_snake_case						)




