

'''simple docstring'''


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

import datasets


lowerCAmelCase__						:       Optional[int]										=						"""\
    @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__						:       Dict										=						"""\
    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__						:       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 	_a       (				__lowerCAmelCase		:      List[Any]   ,							__lowerCAmelCase		:      str     ):

		"""simple docstring"""

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




def 	_a       (				__lowerCAmelCase		:      Tuple   ,							__lowerCAmelCase		:      Dict     ):

		"""simple docstring"""

		snake_case__						:       List[str]       						=  simple_accuracy(__lowerCAmelCase   ,							__lowerCAmelCase     )
		snake_case__						:       Tuple       						=  float(fa_score(y_true=__lowerCAmelCase   ,							y_pred=__lowerCAmelCase     )     )
		return {
		    "accuracy": acc,
		    "f1": fa,
		}




def 	_a       (				__lowerCAmelCase		:      Optional[int]   ,							__lowerCAmelCase		:      int     ):

		"""simple docstring"""

		snake_case__						:       int       						=  np.array(__lowerCAmelCase     )
		snake_case__						:       Union[str, Any]       						=  np.array(__lowerCAmelCase     )
		snake_case__						:       Dict       						=  en_sentvecs.shape[0]

		# mean centering
		snake_case__						:       Tuple       						=  en_sentvecs - np.mean(__lowerCAmelCase   ,							axis=0     )
		snake_case__						:       List[str]       						=  in_sentvecs - np.mean(__lowerCAmelCase   ,							axis=0     )

		snake_case__						:       Optional[int]       						=  cdist(__lowerCAmelCase   ,							__lowerCAmelCase   ,							'''cosine'''     )
		snake_case__						:       List[str]       						=  np.array(range(__lowerCAmelCase     )     )
		snake_case__						:       int       						=  sim.argsort(axis=1     )[:, :10]
		snake_case__						:       Union[str, Any]       						=  np.any(preds == actual[:, None]   ,							axis=1     )
		return float(matches.mean()     )





@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION			,			_KWARGS_DESCRIPTION       )
class     a			(				datasets.Metric       ):






						"""simple docstring"""




						def       __magic_name__							(							self					:      List[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       __magic_name__							(							self					:      List[str]			,			snake_case_					:      List[str]			,			snake_case_					:      Optional[Any]  ):



								'''simple docstring'''



								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'''


from typing import Tuple, Union

from ...modeling_outputs import BackboneOutput
from ...modeling_utils import PreTrainedModel
from ...utils import is_timm_available, is_torch_available, requires_backends
from ...utils.backbone_utils import BackboneMixin
from .configuration_timm_backbone import TimmBackboneConfig


if is_timm_available():
					import timm


if is_torch_available():
					from torch import Tensor




class     a			(				SCREAMING_SNAKE_CASE			,			SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    """pixel_values"""
						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    TimmBackboneConfig







						def __init__(							self					:      str			,			snake_case_					:      str			,			**snake_case_					:      Dict  ):



								'''simple docstring'''



								requires_backends(self			,			'''timm'''  )
								super().__init__(snake_case_  )
								snake_case__						:       List[str]       						=  config

								if config.backbone is None:
										raise ValueError('''backbone is not set in the config. Please set it to a timm model name.'''  )

								if config.backbone not in timm.list_models():
										raise ValueError(F"""backbone {config.backbone} is not supported by timm."""  )

								if hasattr(snake_case_			,			'''out_features'''  ) and config.out_features is not None:
										raise ValueError('''out_features is not supported by TimmBackbone. Please use out_indices instead.'''  )

								snake_case__						:       Dict       						=  getattr(snake_case_			,			'''use_pretrained_backbone'''			,			snake_case_  )
								if pretrained is None:
										raise ValueError('''use_pretrained_backbone is not set in the config. Please set it to True or False.'''  )

								# We just take the final layer by default. This matches the default for the transformers models.
								snake_case__						:       int       						=  config.out_indices if getattr(snake_case_			,			'''out_indices'''			,			snake_case_  ) is not None else (-1,)

								snake_case__						:       Any       						=  timm.create_model(
								    config.backbone			,			pretrained=snake_case_			,			features_only=config.features_only			,			in_chans=config.num_channels			,			out_indices=snake_case_			,			**snake_case_			,			)
								# These are used to control the output of the model when called. If output_hidden_states is True, then
								# return_layers is modified to include all layers.
								snake_case__						:       str       						=  self._backbone.return_layers
								snake_case__						:       List[Any]       						=  {layer['''module''']: str(snake_case_  ) for i, layer in enumerate(self._backbone.feature_info.info  )}
								super()._init_backbone(snake_case_  )







						@classmethod
						def       __magic_name__							(							cls					:      Union[str, Any]			,			snake_case_					:      Union[str, Any]			,			*snake_case_					:      Optional[Any]			,			**snake_case_					:      Optional[Any]  ):



								'''simple docstring'''



								requires_backends(cls			,			['''vision''', '''timm''']  )
								from ...models.timm_backbone import TimmBackboneConfig

								snake_case__						:       Dict       						=  kwargs.pop('''config'''			,			TimmBackboneConfig()  )

								snake_case__						:       Optional[Any]       						=  kwargs.pop('''use_timm_backbone'''			,			snake_case_  )
								if not use_timm:
										raise ValueError('''use_timm_backbone must be True for timm backbones'''  )

								snake_case__						:       List[Any]       						=  kwargs.pop('''num_channels'''			,			config.num_channels  )
								snake_case__						:       Optional[Any]       						=  kwargs.pop('''features_only'''			,			config.features_only  )
								snake_case__						:       Tuple       						=  kwargs.pop('''use_pretrained_backbone'''			,			config.use_pretrained_backbone  )
								snake_case__						:       Union[str, Any]       						=  kwargs.pop('''out_indices'''			,			config.out_indices  )
								snake_case__						:       int       						=  TimmBackboneConfig(
								    backbone=snake_case_			,			num_channels=snake_case_			,			features_only=snake_case_			,			use_pretrained_backbone=snake_case_			,			out_indices=snake_case_			,			)
								return super()._from_config(snake_case_			,			**snake_case_  )







						def       __magic_name__							(							self					:      List[str]			,			snake_case_					:      Union[str, Any]  ):



								'''simple docstring'''



								pass







						def       __magic_name__							(							self					:      Optional[int]			,			snake_case_					:      Union[str, Any]			,			snake_case_					:      Tuple=None			,			snake_case_					:      Tuple=None			,			snake_case_					:      Optional[Any]=None			,			**snake_case_					:      List[str]  ):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  return_dict if return_dict is not None else self.config.use_return_dict
								snake_case__						:       Optional[int]       						=  (
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								snake_case__						:       int       						=  output_attentions if output_attentions is not None else self.config.output_attentions

								if output_attentions:
										raise ValueError('''Cannot output attentions for timm backbones at the moment'''  )

								if output_hidden_states:
										# We modify the return layers to include all the stages of the backbone
										snake_case__						:       Any       						=  self._all_layers
										snake_case__						:       str       						=  self._backbone(snake_case_			,			**snake_case_  )
										snake_case__						:       Tuple       						=  self._return_layers
										snake_case__						:       str       						=  tuple(hidden_states[i] for i in self.out_indices  )
								else:
										snake_case__						:       Dict       						=  self._backbone(snake_case_			,			**snake_case_  )
										snake_case__						:       Any       						=  None

								snake_case__						:       Union[str, Any]       						=  tuple(snake_case_  )
								snake_case__						:       Optional[int]       						=  tuple(snake_case_  ) if hidden_states is not None else None

								if not return_dict:
										snake_case__						:       List[str]       						=  (feature_maps,)
										if output_hidden_states:
												snake_case__						:       Optional[int]       						=  output + (hidden_states,)
										return output

								return BackboneOutput(feature_maps=snake_case_			,			hidden_states=snake_case_			,			attentions=snake_case_  )



