

"""simple docstring"""






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

import datasets


snake_case_   :   str        =       """\
    @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},
}
"""

snake_case_   :   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.
"""

snake_case_   :   Any        =       """
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   lowercase_	(    _lowercase       :		Dict							,      _lowercase       :		Union[str, Any]	):




					'''simple docstring'''






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



def   lowercase_	(    _lowercase       :		Dict							,      _lowercase       :		int	):




					'''simple docstring'''






					UpperCAmelCase			:   Any      =				simple_accuracy(_lowercase							,      _lowercase	)
					UpperCAmelCase			:   Optional[int]      =				float(fa_score(y_true=_lowercase							,      y_pred=_lowercase	)	)
					return {
					    "accuracy": acc,
					    "f1": fa,
					}



def   lowercase_	(    _lowercase       :		Dict							,      _lowercase       :		List[str]	):




					'''simple docstring'''






					UpperCAmelCase			:   Optional[int]      =				np.array(_lowercase	)
					UpperCAmelCase			:   int      =				np.array(_lowercase	)
					UpperCAmelCase			:   Optional[Any]      =				en_sentvecs.shape[0]

					# mean centering
					UpperCAmelCase			:   Any      =				en_sentvecs - np.mean(_lowercase							,      axis=0	)
					UpperCAmelCase			:   str      =				in_sentvecs - np.mean(_lowercase							,      axis=0	)

					UpperCAmelCase			:   List[Any]      =				cdist(_lowercase							,      _lowercase							,      "cosine"	)
					UpperCAmelCase			:   List[Any]      =				np.array(range(_lowercase	)	)
					UpperCAmelCase			:   str      =				sim.argsort(axis=1	)[:, :10]
					UpperCAmelCase			:   Optional[Any]      =				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 			__lowerCAmelCase				(			self			: Tuple  ):





								'''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			: List[str]			,  lowercase			: List[Any]			,  lowercase			: int  ):





								'''simple docstring'''



								if self.config_name == "cvit-mkb-clsr":
													return {"precision@10": precision_at_aa(lowercase			,  lowercase  )}
								elif self.config_name in ["wiki-ner"]:
													return acc_and_fa(lowercase			,  lowercase  )
								elif self.config_name in [
								    "wnli",
								    "copa",
								    "sna",
								    "csqa",
								    "wstp",
								    "inltkh",
								    "bbca",
								    "iitp-mr",
								    "iitp-pr",
								    "actsa-sc",
								    "md",
								]:
													return {"accuracy": simple_accuracy(lowercase			,  lowercase  )}
								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"""






def   lowercase_	(    _lowercase       :		List[str]							,      _lowercase       :		Tuple							,      _lowercase       :		int							,      _lowercase       :		Optional[Any]	):




					'''simple docstring'''






					UpperCAmelCase			:   int      =				[False] * len(_lowercase	)
					UpperCAmelCase			:   List[str]      =				[]
					queue.append(_lowercase	)
					UpperCAmelCase			:   List[Any]      =				True

					while queue:
										UpperCAmelCase			:   Any      =				queue.pop(0	)
										for ind in range(len(graph[u]	)	):
															if visited[ind] is False and graph[u][ind] > 0:
																				queue.append(_lowercase	)
																				UpperCAmelCase			:   Optional[int]      =				True
																				UpperCAmelCase			:   int      =				u

					return visited[t]



def   lowercase_	(    _lowercase       :		Tuple							,      _lowercase       :		Dict							,      _lowercase       :		Optional[int]	):




					'''simple docstring'''






					UpperCAmelCase			:   List[Any]      =				[-1] * (len(_lowercase	))
					UpperCAmelCase			:   List[Any]      =				0
					while bfs(_lowercase							,      _lowercase							,      _lowercase							,      _lowercase	):
										UpperCAmelCase			:   List[str]      =				float("Inf"	)
										UpperCAmelCase			:   str      =				sink

										while s != source:
															# Find the minimum value in select path
															UpperCAmelCase			:   Tuple      =				min(_lowercase							,      graph[parent[s]][s]	)
															UpperCAmelCase			:   Optional[Any]      =				parent[s]

										max_flow += path_flow
										UpperCAmelCase			:   List[str]      =				sink

										while v != source:
															UpperCAmelCase			:   Dict      =				parent[v]
															graph[u][v] -= path_flow
															graph[v][u] += path_flow
															UpperCAmelCase			:   Dict      =				parent[v]
					return max_flow


snake_case_   :   Optional[Any]        =       [
    [0, 1_6, 1_3, 0, 0, 0],
    [0, 0, 1_0, 1_2, 0, 0],
    [0, 4, 0, 0, 1_4, 0],
    [0, 0, 9, 0, 0, 2_0],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]

snake_case_     ,      snake_case_   :   str        =       0, 5




print(ford_fulkerson(graph, source, sink))


