



"""simple docstring"""





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

import datasets


lowercase  							=					'''\
    @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},
}
'''

lowercase  							=					'''\
    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.
'''

lowercase  							=					'''
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     (		A	:						Optional[int]     ,				A	:						List[str]       ):

		'''simple docstring'''


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




def 	UpperCAmelCase     (		A	:						List[str]     ,				A	:						Dict       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		simple_accuracy(A     ,				A       )
		_UpperCAmelCase							 =		float(fa_score(y_true=A     ,				y_pred=A       )       )
		return {
		    "accuracy": acc,
		    "f1": fa,
		}




def 	UpperCAmelCase     (		A	:						Optional[int]     ,				A	:						Optional[int]       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		np.array(A       )
		_UpperCAmelCase							 =		np.array(A       )
		_UpperCAmelCase							 =		en_sentvecs.shape[0]

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

		_UpperCAmelCase							 =		cdist(A     ,				A     ,				'cosine'       )
		_UpperCAmelCase							 =		np.array(range(A       )       )
		_UpperCAmelCase							 =		sim.argsort(axis=1       )[:, :10]
		_UpperCAmelCase							 =		np.any(preds == actual[:, None]     ,				axis=1       )
		return float(matches.mean()       )






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION,					_KWARGS_DESCRIPTION    )
class 			lowercase__			(      datasets.Metric    ):
							'''simple docstring'''







							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									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	,       snake_case	,       snake_case						)			->							Optional[Any]:
									if self.config_name == "cvit-mkb-clsr":
											return {"precision@10": precision_at_aa(snake_case	,       snake_case						)}
									elif self.config_name in ["wiki-ner"]:
											return acc_and_fa(snake_case	,       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(snake_case	,       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"]'						)







"""simple docstring"""





import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TextaTextGenerationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch
from transformers.utils import is_torch_available

from .test_pipelines_common import ANY


if is_torch_available():
					import torch




@is_pipeline_test
class 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							_UpperCAmelCase      				=					MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
							_UpperCAmelCase      				=					TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case						)			->							Dict:
									_UpperCAmelCase							 =		TextaTextGenerationPipeline(model=snake_case	,       tokenizer=snake_case						)
									return generator, ["Something to write", "Something else"]






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							Dict:
									_UpperCAmelCase							 =		generator('Something there'						)
									self.assertEqual(snake_case	,       [{'generated_text': ANY(snake_case						)}]						)
									# These are encoder decoder, they don't just append to incoming string
									self.assertFalse(outputs[0]['generated_text'].startswith('Something there'						)						)

									_UpperCAmelCase							 =		generator(['This is great !', 'Something else']	,       num_return_sequences=2	,       do_sample=snake_case						)
									self.assertEqual(
									    snake_case	,       [
									        [{'generated_text': ANY(snake_case						)}, {'generated_text': ANY(snake_case						)}],
									        [{'generated_text': ANY(snake_case						)}, {'generated_text': ANY(snake_case						)}],
									    ]	,       )

									_UpperCAmelCase							 =		generator(
									    ['This is great !', 'Something else']	,       num_return_sequences=2	,       batch_size=2	,       do_sample=snake_case						)
									self.assertEqual(
									    snake_case	,       [
									        [{'generated_text': ANY(snake_case						)}, {'generated_text': ANY(snake_case						)}],
									        [{'generated_text': ANY(snake_case						)}, {'generated_text': ANY(snake_case						)}],
									    ]	,       )

									with self.assertRaises(snake_case						):
											generator(4						)






							@require_torch
							def        lowerCamelCase_   (  self						)			->							Dict:
									_UpperCAmelCase							 =		pipeline('text2text-generation'	,       model='patrickvonplaten/t5-tiny-random'	,       framework='pt'						)
									# do_sample=False necessary for reproducibility
									_UpperCAmelCase							 =		generator('Something there'	,       do_sample=snake_case						)
									self.assertEqual(snake_case	,       [{'generated_text': ''}]						)

									_UpperCAmelCase							 =		3
									_UpperCAmelCase							 =		generator(
									    'Something there'	,       num_return_sequences=snake_case	,       num_beams=snake_case	,       )
									_UpperCAmelCase							 =		[
									    {'generated_text': 'Beide Beide Beide Beide Beide Beide Beide Beide Beide'},
									    {'generated_text': 'Beide Beide Beide Beide Beide Beide Beide Beide'},
									    {'generated_text': ''},
									]
									self.assertEqual(snake_case	,       snake_case						)

									_UpperCAmelCase							 =		generator('This is a test'	,       do_sample=snake_case	,       num_return_sequences=2	,       return_tensors=snake_case						)
									self.assertEqual(
									    snake_case	,       [
									        {'generated_token_ids': ANY(torch.Tensor						)},
									        {'generated_token_ids': ANY(torch.Tensor						)},
									    ]	,       )
									_UpperCAmelCase							 =		generator.model.config.eos_token_id
									_UpperCAmelCase							 =		'<pad>'
									_UpperCAmelCase							 =		generator(
									    ['This is a test', 'This is a second test']	,       do_sample=snake_case	,       num_return_sequences=2	,       batch_size=2	,       return_tensors=snake_case	,       )
									self.assertEqual(
									    snake_case	,       [
									        [
									            {'generated_token_ids': ANY(torch.Tensor						)},
									            {'generated_token_ids': ANY(torch.Tensor						)},
									        ],
									        [
									            {'generated_token_ids': ANY(torch.Tensor						)},
									            {'generated_token_ids': ANY(torch.Tensor						)},
									        ],
									    ]	,       )






							@require_tf
							def        lowerCamelCase_   (  self						)			->							Any:
									_UpperCAmelCase							 =		pipeline('text2text-generation'	,       model='patrickvonplaten/t5-tiny-random'	,       framework='tf'						)
									# do_sample=False necessary for reproducibility
									_UpperCAmelCase							 =		generator('Something there'	,       do_sample=snake_case						)
									self.assertEqual(snake_case	,       [{'generated_text': ''}]						)


