






from copy import deepcopy
from typing import Optional, Union

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, is_tf_available, is_torch_available


if is_torch_available():
				import torch

if is_tf_available():
				import tensorflow as tf

class 		_snake_case  (  _a					):
							_lowercase		:    Optional[int]			     =							["""image_processor"""]
							_lowercase		:    List[Any]			     =							"""SamImageProcessor"""






							def __init__(       self		,					a)      ->       Any:
										super().__init__(snake_case_)
										SCREAMING_SNAKE_CASE						= self.image_processor
										SCREAMING_SNAKE_CASE						= -10
										SCREAMING_SNAKE_CASE						= self.image_processor.size['longest_edge']






							def __call__(       self		,					a=None		,					a=None		,					a=None		,					a=None		,					a = None		,					**a		,					)      ->       BatchEncoding:
										SCREAMING_SNAKE_CASE						= self.image_processor(
										    snake_case_		,					return_tensors=snake_case_		,					**snake_case_		,					)

										# pop arguments that are not used in the foward but used nevertheless
										SCREAMING_SNAKE_CASE						= encoding_image_processor['original_sizes']

										if hasattr(snake_case_		,					'numpy'):  # Checks if Torch or TF tensor
													SCREAMING_SNAKE_CASE						= original_sizes.numpy()

										SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						= self._check_and_preprocess_points(
										    input_points=snake_case_		,					input_labels=snake_case_		,					input_boxes=snake_case_		,					)

										SCREAMING_SNAKE_CASE						= self._normalize_and_convert(
										    snake_case_		,					snake_case_		,					input_points=snake_case_		,					input_labels=snake_case_		,					input_boxes=snake_case_		,					return_tensors=snake_case_		,					)

										return encoding_image_processor






							def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a=None		,					a=None		,					a=None		,					a="pt"		,					)      ->       Tuple:
										if input_points is not None:
													if len(snake_case_) != len(snake_case_):
																SCREAMING_SNAKE_CASE						= [
																    self._normalize_coordinates(self.target_size		,					snake_case_		,					original_sizes[0]) for point in input_points
																]
													else:
																SCREAMING_SNAKE_CASE						= [
																    self._normalize_coordinates(self.target_size		,					snake_case_		,					snake_case_)
																    for point, original_size in zip(snake_case_		,					snake_case_)
																]
													# check that all arrays have the same shape
													if not all(point.shape == input_points[0].shape for point in input_points):
																if input_labels is not None:
																			SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						= self._pad_points_and_labels(snake_case_		,					snake_case_)

													SCREAMING_SNAKE_CASE						= np.array(snake_case_)

										if input_labels is not None:
													SCREAMING_SNAKE_CASE						= np.array(snake_case_)

										if input_boxes is not None:
													if len(snake_case_) != len(snake_case_):
																SCREAMING_SNAKE_CASE						= [
																    self._normalize_coordinates(self.target_size		,					snake_case_		,					original_sizes[0]		,					is_bounding_box=snake_case_)
																    for box in input_boxes
																]
													else:
																SCREAMING_SNAKE_CASE						= [
																    self._normalize_coordinates(self.target_size		,					snake_case_		,					snake_case_		,					is_bounding_box=snake_case_)
																    for box, original_size in zip(snake_case_		,					snake_case_)
																]
													SCREAMING_SNAKE_CASE						= np.array(snake_case_)

										if input_boxes is not None:
													if return_tensors == "pt":
																SCREAMING_SNAKE_CASE						= torch.from_numpy(snake_case_)
																# boxes batch size of 1 by default
																SCREAMING_SNAKE_CASE						= input_boxes.unsqueeze(1) if len(input_boxes.shape) != 3 else input_boxes
													elif return_tensors == "tf":
																SCREAMING_SNAKE_CASE						= tf.convert_to_tensor(snake_case_)
																# boxes batch size of 1 by default
																SCREAMING_SNAKE_CASE						= tf.expand_dims(snake_case_		,					1) if len(input_boxes.shape) != 3 else input_boxes
													encoding_image_processor.update({'input_boxes': input_boxes})
										if input_points is not None:
													if return_tensors == "pt":
																SCREAMING_SNAKE_CASE						= torch.from_numpy(snake_case_)
																# point batch size of 1 by default
																SCREAMING_SNAKE_CASE						= input_points.unsqueeze(1) if len(input_points.shape) != 4 else input_points
													elif return_tensors == "tf":
																SCREAMING_SNAKE_CASE						= tf.convert_to_tensor(snake_case_)
																# point batch size of 1 by default
																SCREAMING_SNAKE_CASE						= tf.expand_dims(snake_case_		,					1) if len(input_points.shape) != 4 else input_points
													encoding_image_processor.update({'input_points': input_points})
										if input_labels is not None:
													if return_tensors == "pt":
																SCREAMING_SNAKE_CASE						= torch.from_numpy(snake_case_)
																# point batch size of 1 by default
																SCREAMING_SNAKE_CASE						= input_labels.unsqueeze(1) if len(input_labels.shape) != 3 else input_labels
													elif return_tensors == "tf":
																SCREAMING_SNAKE_CASE						= tf.convert_to_tensor(snake_case_)
																# point batch size of 1 by default
																SCREAMING_SNAKE_CASE						= tf.expand_dims(snake_case_		,					1) if len(input_labels.shape) != 3 else input_labels
													encoding_image_processor.update({'input_labels': input_labels})

										return encoding_image_processor






							def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a)      ->       List[str]:
										SCREAMING_SNAKE_CASE						= max([point.shape[0] for point in input_points])
										SCREAMING_SNAKE_CASE						= []
										for i, point in enumerate(snake_case_):
													if point.shape[0] != expected_nb_points:
																SCREAMING_SNAKE_CASE						= np.concatenate(
																    [point, np.zeros((expected_nb_points - point.shape[0], 2)) + self.point_pad_value]		,					axis=0)
																SCREAMING_SNAKE_CASE						= np.append(input_labels[i]		,					[self.point_pad_value])
													processed_input_points.append(snake_case_)
										SCREAMING_SNAKE_CASE						= processed_input_points
										return input_points, input_labels






							def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a		,					a=False)      ->       np.ndarray:
										SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						= original_size
										SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						= self.image_processor._get_preprocess_shape(snake_case_		,					longest_edge=snake_case_)
										SCREAMING_SNAKE_CASE						= deepcopy(snake_case_).astype(snake_case_)

										if is_bounding_box:
													SCREAMING_SNAKE_CASE						= coords.reshape(-1		,					2		,					2)

										SCREAMING_SNAKE_CASE						= coords[..., 0] * (new_w / old_w)
										SCREAMING_SNAKE_CASE						= coords[..., 1] * (new_h / old_h)

										if is_bounding_box:
													SCREAMING_SNAKE_CASE						= coords.reshape(-1		,					4)

										return coords






							def    SCREAMING_SNAKE_CASE__    (       self		,					a=None		,					a=None		,					a=None		,					)      ->       Union[str, Any]:
										if input_points is not None:
													if hasattr(snake_case_		,					'numpy'):  # Checks for TF or Torch tensor
																SCREAMING_SNAKE_CASE						= input_points.numpy().tolist()

													if not isinstance(snake_case_		,					snake_case_) or not isinstance(input_points[0]		,					snake_case_):
																raise ValueError('Input points must be a list of list of floating points.')
													SCREAMING_SNAKE_CASE						= [np.array(snake_case_) for input_point in input_points]
										else:
													SCREAMING_SNAKE_CASE						= None

										if input_labels is not None:
													if hasattr(snake_case_		,					'numpy'):
																SCREAMING_SNAKE_CASE						= input_labels.numpy().tolist()

													if not isinstance(snake_case_		,					snake_case_) or not isinstance(input_labels[0]		,					snake_case_):
																raise ValueError('Input labels must be a list of list integers.')
													SCREAMING_SNAKE_CASE						= [np.array(snake_case_) for label in input_labels]
										else:
													SCREAMING_SNAKE_CASE						= None

										if input_boxes is not None:
													if hasattr(snake_case_		,					'numpy'):
																SCREAMING_SNAKE_CASE						= input_boxes.numpy().tolist()

													if (
													    not isinstance(snake_case_		,					snake_case_)
													    or not isinstance(input_boxes[0]		,					snake_case_)
													    or not isinstance(input_boxes[0][0]		,					snake_case_)
													):
																raise ValueError('Input boxes must be a list of list of list of floating points.')
													SCREAMING_SNAKE_CASE						= [np.array(snake_case_).astype(np.floataa) for box in input_boxes]
										else:
													SCREAMING_SNAKE_CASE						= None

										return input_points, input_labels, input_boxes






							@property
							def    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[int]:
										SCREAMING_SNAKE_CASE						= self.image_processor.model_input_names
										return list(dict.fromkeys(snake_case_))







							def    SCREAMING_SNAKE_CASE__    (       self		,					*a		,					**a)      ->       Dict:
										return self.image_processor.post_process_masks(*snake_case_		,					**snake_case_)












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

import datasets


a_		:						Optional[int]             =    '\\n    @inproceedings{kakwani2020indicnlpsuite,\n    title={{IndicNLPSuite: Monolingual Corpora, Evaluation Benchmarks and Pre-trained Multilingual Language Models for Indian Languages}},\n    author={Divyanshu Kakwani and Anoop Kunchukuttan and Satish Golla and Gokul N.C. and Avik Bhattacharyya and Mitesh M. Khapra and Pratyush Kumar},\n    year={2020},\n    booktitle={Findings of EMNLP},\n}\n'

a_		:						Tuple             =    '\\n    IndicGLUE is a natural language understanding benchmark for Indian languages. It contains a wide\n    variety of tasks and covers 11 major Indian languages - as, bn, gu, hi, kn, ml, mr, or, pa, ta, te.\n'

a_		:						Optional[Any]             =    '\nCompute IndicGLUE evaluation metric associated to each IndicGLUE dataset.\nArgs:\n    predictions: list of predictions to score (as int64),\n        except for \'cvit-mkb-clsr\' where each prediction is a vector (of float32).\n    references: list of ground truth labels corresponding to the predictions (as int64),\n        except for \'cvit-mkb-clsr\' where each reference is a vector (of float32).\nReturns: depending on the IndicGLUE subset, one or several of:\n    "accuracy": Accuracy\n    "f1": F1 score\n    "precision": Precision@10\nExamples:\n\n    >>> 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"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'wiki-ner\')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0, \'f1\': 1.0}\n\n    >>> indic_glue_metric = datasets.load_metric(\'indic_glue\', \'cvit-mkb-clsr\')\n    >>> references = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> predictions = [[0.5, 0.5, 0.5], [0.1, 0.2, 0.3]]\n    >>> results = indic_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'precision@10\': 1.0}\n\n'






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			return float((preds == labels).mean())






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






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= np.array(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= np.array(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= en_sentvecs.shape[0]

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

			SCREAMING_SNAKE_CASE						= cdist(_UpperCAmelCase							,       _UpperCAmelCase							,       'cosine')
			SCREAMING_SNAKE_CASE						= np.array(range(_UpperCAmelCase))
			SCREAMING_SNAKE_CASE						= sim.argsort(axis=1)[:, :10]
			SCREAMING_SNAKE_CASE						= 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					):






			def    SCREAMING_SNAKE_CASE__    (       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    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a)      ->       List[Any]:
						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"]')




