



"""simple docstring"""




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

import datasets


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

_UpperCamelCase: Optional[int]										=     '\\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'

_UpperCamelCase: Tuple										=     '\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      lowercase__   (	_UpperCAmelCase		,					_UpperCAmelCase )   ->	Optional[int]:






      '''simple docstring'''


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


def      lowercase__   (	_UpperCAmelCase		,					_UpperCAmelCase )   ->	str:






      '''simple docstring'''


      lowercase     :					Dict 		=      simple_accuracy(lowerCAmelCase_		,					lowerCAmelCase_ )
      lowercase     :					Dict 		=      float(fa_score(y_true=lowerCAmelCase_		,					y_pred=lowerCAmelCase_ ) )
      return {
          "accuracy": acc,
          "f1": fa,
      }


def      lowercase__   (	_UpperCAmelCase		,					_UpperCAmelCase )   ->	List[str]:






      '''simple docstring'''


      lowercase     :					List[Any] 		=      np.array(lowerCAmelCase_ )
      lowercase     :					Optional[Any] 		=      np.array(lowerCAmelCase_ )
      lowercase     :					Optional[Any] 		=      en_sentvecs.shape[0]

      # mean centering
      lowercase     :					Dict 		=      en_sentvecs - np.mean(lowerCAmelCase_		,					axis=0 )
      lowercase     :					Optional[Any] 		=      in_sentvecs - np.mean(lowerCAmelCase_		,					axis=0 )

      lowercase     :					str 		=      cdist(lowerCAmelCase_		,					lowerCAmelCase_		,					'cosine' )
      lowercase     :					str 		=      np.array(range(lowerCAmelCase_ ) )
      lowercase     :					Any 		=      sim.argsort(axis=1 )[:, :10]
      lowercase     :					Optional[int] 		=      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   ):


   def 				lowercase (							self					:							Optional[int]	)			->				List[Any]:
         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 				lowercase (							self					:							Union[str, Any],   lowerCAmelCase					:							List[str],   lowerCAmelCase					:							str	)			->				Optional[Any]:
         if self.config_name == "cvit-mkb-clsr":
               return {"precision@10": precision_at_aa(_UpperCAmelCase,   _UpperCAmelCase	)}
         elif self.config_name in ["wiki-ner"]:
               return acc_and_fa(_UpperCAmelCase,   _UpperCAmelCase	)
         elif self.config_name in [
             "wnli",
             "copa",
             "sna",
             "csqa",
             "wstp",
             "inltkh",
             "bbca",
             "iitp-mr",
             "iitp-pr",
             "actsa-sc",
             "md",
         ]:
               return {"accuracy": simple_accuracy(_UpperCAmelCase,   _UpperCAmelCase	)}
         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 multiprocessing
from typing import TYPE_CHECKING, Optional, Union

from .. import Dataset, Features, config
from ..formatting import query_table
from ..packaged_modules.sql.sql import Sql
from ..utils import logging
from .abc import AbstractDatasetInputStream


if TYPE_CHECKING:
							import sqlitea

							import sqlalchemy

class 	__magic_name__						(    _UpperCamelCase   ):







							def __init__(							self					:       Optional[int]	,_UpperCAmelCase					:       Union[str, "sqlalchemy.sql.Selectable"]	,_UpperCAmelCase					:       Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"]	,_UpperCAmelCase					:       Optional[Features] = None	,_UpperCAmelCase					:       str = None	,_UpperCAmelCase					:       bool = False	,**_UpperCAmelCase					:       Dict	,):
									super().__init__(features=_UpperCAmelCase	,cache_dir=_UpperCAmelCase	,keep_in_memory=_UpperCAmelCase	,**_UpperCAmelCase		)
									_a     :      Tuple        =							Sql(
									    cache_dir=_UpperCAmelCase	,features=_UpperCAmelCase	,sql=_UpperCAmelCase	,con=_UpperCAmelCase	,**_UpperCAmelCase	,)







							def 							__lowercase			(							self					:       Dict		):
									_a     :      Optional[Any]        =							None
									_a     :      Dict        =							None
									_a     :      Dict        =							None
									_a     :      Optional[int]        =							None

									self.builder.download_and_prepare(
									    download_config=_UpperCAmelCase	,download_mode=_UpperCAmelCase	,verification_mode=_UpperCAmelCase	,base_path=_UpperCAmelCase	,)

									# Build dataset for splits
									_a     :      List[str]        =							self.builder.as_dataset(
									    split='train'	,verification_mode=_UpperCAmelCase	,in_memory=self.keep_in_memory		)
									return dataset

class 	__magic_name__						:







							def __init__(							self					:       Optional[int]	,_UpperCAmelCase					:       Dataset	,_UpperCAmelCase					:       str	,_UpperCAmelCase					:       Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"]	,_UpperCAmelCase					:       Optional[int] = None	,_UpperCAmelCase					:       Optional[int] = None	,**_UpperCAmelCase					:       Dict	,):
									if num_proc is not None and num_proc <= 0:
											raise ValueError(F"""num_proc {num_proc} must be an integer > 0."""		)

									_a     :      Dict        =							dataset
									_a     :      List[Any]        =							name
									_a     :      Tuple        =							con
									_a     :      Union[str, Any]        =							batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
									_a     :      List[Any]        =							num_proc
									_a     :      Tuple        =							to_sql_kwargs







							def 							__lowercase			(							self					:       List[Any]		):
									_a     :      Tuple        =							self.to_sql_kwargs.pop('sql'	,_UpperCAmelCase		)
									_a     :      str        =							self.to_sql_kwargs.pop('con'	,_UpperCAmelCase		)
									_a     :      Optional[Any]        =							self.to_sql_kwargs.pop('index'	,_UpperCAmelCase		)

									_a     :      Any        =							self._write(index=_UpperCAmelCase	,**self.to_sql_kwargs		)
									return written







							def 							__lowercase			(							self					:       Optional[int]	,_UpperCAmelCase					:       Dict		):
									_a       ,					_a       ,					_a     :      Any        =							args
									_a     :      Tuple        =							{**to_sql_kwargs, 'if_exists': 'append'} if offset > 0 else to_sql_kwargs
									_a     :      Dict        =							query_table(
									    table=self.dataset.data	,key=slice(_UpperCAmelCase	,offset + self.batch_size		)	,indices=self.dataset._indices	,)
									_a     :      Tuple        =							batch.to_pandas()
									_a     :      Dict        =							df.to_sql(self.name	,self.con	,index=_UpperCAmelCase	,**_UpperCAmelCase		)
									return num_rows or len(_UpperCAmelCase		)







							def 							__lowercase			(							self					:       int	,_UpperCAmelCase					:       Optional[int]	,**_UpperCAmelCase					:       List[Any]		):
									_a     :      Union[str, Any]        =							0

									if self.num_proc is None or self.num_proc == 1:
											for offset in logging.tqdm(
											    range(0	,len(self.dataset		)	,self.batch_size		)	,unit='ba'	,disable=not logging.is_progress_bar_enabled()	,desc='Creating SQL from Arrow format'	,):
													written += self._batch_sql((offset, index, to_sql_kwargs)		)
									else:
											_a       ,					_a     :      List[Any]        =							len(self.dataset		), self.batch_size
											with multiprocessing.Pool(self.num_proc		) as pool:
													for num_rows in logging.tqdm(
													    pool.imap(
													        self._batch_sql	,[(offset, index, to_sql_kwargs) for offset in range(0	,_UpperCAmelCase	,_UpperCAmelCase		)]	,)	,total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size	,unit='ba'	,disable=not logging.is_progress_bar_enabled()	,desc='Creating SQL from Arrow format'	,):
															written += num_rows

									return written




