




from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


__A						:							Optional[Any]							=  """\
@inproceedings{wang2019glue,
  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
  note={In the Proceedings of ICLR.},
  year={2019}
}
"""

__A						:							Any							=  """\
GLUE, the General Language Understanding Evaluation benchmark
(https://gluebenchmark.com/) is a collection of resources for training,
evaluating, and analyzing natural language understanding systems.
"""

__A						:							Any							=  """
Compute GLUE evaluation metric associated to each GLUE dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
Returns: depending on the GLUE subset, one or several of:
    \"accuracy\": Accuracy
    \"f1\": F1 score
    \"pearson\": Pearson Correlation
    \"spearmanr\": Spearman Correlation
    \"matthews_correlation\": Matthew Correlation
Examples:

    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'stsb')
    >>> references = [0., 1., 2., 3., 4., 5.]
    >>> predictions = [0., 1., 2., 3., 4., 5.]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})
    {'pearson': 1.0, 'spearmanr': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'cola')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'matthews_correlation': 1.0}
"""
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			return float((preds == labels).mean()   )
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					simple_accuracy(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   )
			SCREAMING_SNAKE_CASE           =					float(fa_score(y_true=SCREAMING_SNAKE_CASE					,	y_pred=SCREAMING_SNAKE_CASE   )   )
			return {
			    "accuracy": acc,
			    "f1": fa,
			}
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					float(pearsonr(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   )[0]   )
			SCREAMING_SNAKE_CASE           =					float(spearmanr(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   )[0]   )
			return {
			    "pearson": pearson_corr,
			    "spearmanr": spearman_corr,
			}




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




							'''simple docstring'''



							def    _UpperCAmelCase     (					self       :	int			)			->					Optional[int]:
										if self.config_name not in [
										    "sst2",
										    "mnli",
										    "mnli_mismatched",
										    "mnli_matched",
										    "cola",
										    "stsb",
										    "mrpc",
										    "qqp",
										    "qnli",
										    "rte",
										    "wnli",
										    "hans",
										]:
													raise KeyError(
													    """You should supply a configuration name selected in """
													    """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """
													    """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]"""			)
										return datasets.MetricInfo(
										    description=_DESCRIPTION       ,     citation=_CITATION       ,     inputs_description=_KWARGS_DESCRIPTION       ,     features=datasets.Features(
										        {
										            """predictions""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32"""			),
										            """references""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32"""			),
										        }			)       ,     codebase_urls=[]       ,     reference_urls=[]       ,     format="""numpy"""       ,     )







							def    _UpperCAmelCase     (					self       :	Tuple       ,     a       :	Dict       ,     a       :	Optional[Any]			)			->					Tuple:
										if self.config_name == "cola":
													return {"matthews_correlation": matthews_corrcoef(a       ,     a			)}
										elif self.config_name == "stsb":
													return pearson_and_spearman(a       ,     a			)
										elif self.config_name in ["mrpc", "qqp"]:
													return acc_and_fa(a       ,     a			)
										elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
													return {"accuracy": simple_accuracy(a       ,     a			)}
										else:
													raise KeyError(
													    """You should supply a configuration name selected in """
													    """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """
													    """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]"""			)












import os
from shutil import copyfile
from typing import List, Optional, Tuple

from tokenizers import processors

from ...tokenization_utils import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
		from .tokenization_mbart import MBartTokenizer
else:
		__A						:							Tuple							=  None


__A						:							Any							=  logging.get_logger(__name__)


__A						:							Union[str, Any]							=  {"""vocab_file""": """sentencepiece.bpe.model""", """tokenizer_file""": """tokenizer.json"""}

__A						:							List[Any]							=  {
    """vocab_file""": {
        """facebook/mbart-large-en-ro""": (
            """https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model"""
        ),
        """facebook/mbart-large-cc25""": (
            """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model"""
        ),
    },
    """tokenizer_file""": {
        """facebook/mbart-large-en-ro""": """https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json""",
        """facebook/mbart-large-cc25""": """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json""",
    },
}

__A						:							int							=  {
    """facebook/mbart-large-en-ro""": 1_0_2_4,
    """facebook/mbart-large-cc25""": 1_0_2_4,
}

# fmt: off
__A						:							List[Any]							=  ["""ar_AR""", """cs_CZ""", """de_DE""", """en_XX""", """es_XX""", """et_EE""", """fi_FI""", """fr_XX""", """gu_IN""", """hi_IN""", """it_IT""", """ja_XX""", """kk_KZ""", """ko_KR""", """lt_LT""", """lv_LV""", """my_MM""", """ne_NP""", """nl_XX""", """ro_RO""", """ru_RU""", """si_LK""", """tr_TR""", """vi_VN""", """zh_CN"""]




class 			UpperCAmelCase_      (   A       ):




							'''simple docstring'''



							a__						  =     VOCAB_FILES_NAMES
							a__						  =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							a__						  =     PRETRAINED_VOCAB_FILES_MAP
							a__						  =     ['''input_ids''', '''attention_mask''']
							a__						  =     MBartTokenizer

							a__						  =     []
							a__						  =     []





							def __init__(					self       :	str       ,     a       :	List[Any]=None       ,     a       :	Optional[int]=None       ,     a       :	str="<s>"       ,     a       :	Tuple="</s>"       ,     a       :	Optional[int]="</s>"       ,     a       :	int="<s>"       ,     a       :	List[str]="<unk>"       ,     a       :	Tuple="<pad>"       ,     a       :	Dict="<mask>"       ,     a       :	Optional[Any]=None       ,     a       :	List[Any]=None       ,     a       :	Any=None       ,     **a       :	Optional[Any]       ,     )			->					Any:
										# Mask token behave like a normal word, i.e. include the space before it
										SCREAMING_SNAKE_CASE           =					AddedToken(a       ,     lstrip=a       ,     rstrip=a			) if isinstance(a       ,     a			) else mask_token

										super().__init__(
										    vocab_file=a       ,     tokenizer_file=a       ,     bos_token=a       ,     eos_token=a       ,     sep_token=a       ,     cls_token=a       ,     unk_token=a       ,     pad_token=a       ,     mask_token=a       ,     src_lang=a       ,     tgt_lang=a       ,     additional_special_tokens=a       ,     **a       ,     )

										SCREAMING_SNAKE_CASE           =					vocab_file
										SCREAMING_SNAKE_CASE           =					False if not self.vocab_file else True

										SCREAMING_SNAKE_CASE           =					FAIRSEQ_LANGUAGE_CODES.copy()

										if additional_special_tokens is not None:
													# Only add those special tokens if they are not already there.
													_additional_special_tokens.extend(
													    [t for t in additional_special_tokens if t not in _additional_special_tokens]			)

										self.add_special_tokens({"""additional_special_tokens""": _additional_special_tokens}			)
										SCREAMING_SNAKE_CASE           =					{
										    lang_code: self.convert_tokens_to_ids(a			) for lang_code in FAIRSEQ_LANGUAGE_CODES
										}

										SCREAMING_SNAKE_CASE           =					src_lang if src_lang is not None else """en_XX"""
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(self._src_lang			)
										SCREAMING_SNAKE_CASE           =					tgt_lang
										self.set_src_lang_special_tokens(self._src_lang			)





							@property
							def    _UpperCAmelCase     (					self       :	int			)			->					str:
										return self._src_lang





							@src_lang.setter
							def    _UpperCAmelCase     (					self       :	List[Any]       ,     a       :	str			)			->					None:
										SCREAMING_SNAKE_CASE           =					new_src_lang
										self.set_src_lang_special_tokens(self._src_lang			)





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	List[int]       ,     a       :	Optional[List[int]] = None			)			->					List[int]:
										if token_ids_a is None:
													return self.prefix_tokens + token_ids_a + self.suffix_tokens
										# We don't expect to process pairs, but leave the pair logic for API consistency
										return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens





							def    _UpperCAmelCase     (					self       :	Tuple       ,     a       :	List[int]       ,     a       :	Optional[List[int]] = None			)			->					List[int]:
										SCREAMING_SNAKE_CASE           =					[self.sep_token_id]
										SCREAMING_SNAKE_CASE           =					[self.cls_token_id]

										if token_ids_a is None:
													return len(cls + token_ids_a + sep			) * [0]
										return len(cls + token_ids_a + sep + sep + token_ids_a + sep			) * [0]





							def    _UpperCAmelCase     (					self       :	Optional[Any]       ,     a       :	Optional[int]       ,     a       :	str       ,     a       :	Optional[str]       ,     a       :	Optional[str]       ,     **a       :	Optional[Any]			)			->					Optional[Any]:
										if src_lang is None or tgt_lang is None:
													raise ValueError("""Translation requires a `src_lang` and a `tgt_lang` for this model"""			)
										SCREAMING_SNAKE_CASE           =					src_lang
										SCREAMING_SNAKE_CASE           =					self(a       ,     add_special_tokens=a       ,     return_tensors=a       ,     **a			)
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(a			)
										SCREAMING_SNAKE_CASE           =					tgt_lang_id
										return inputs





							def    _UpperCAmelCase     (					self       :	str       ,     a       :	List[str]       ,     a       :	str = "en_XX"       ,     a       :	Optional[List[str]] = None       ,     a       :	str = "ro_RO"       ,     **a       :	List[str]       ,     )			->					BatchEncoding:
										SCREAMING_SNAKE_CASE           =					src_lang
										SCREAMING_SNAKE_CASE           =					tgt_lang
										return super().prepare_seqaseq_batch(a       ,     a       ,     **a			)





							def    _UpperCAmelCase     (					self       :	Optional[Any]			)			->					str:
										return self.set_src_lang_special_tokens(self.src_lang			)





							def    _UpperCAmelCase     (					self       :	str			)			->					List[str]:
										return self.set_tgt_lang_special_tokens(self.tgt_lang			)





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	List[str]			)			->					None:
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(a			)
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[self.eos_token_id, self.cur_lang_code]

										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.prefix_tokens			)
										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.suffix_tokens			)

										SCREAMING_SNAKE_CASE           =					processors.TemplateProcessing(
										    single=prefix_tokens_str + ["""$A"""] + suffix_tokens_str       ,     pair=prefix_tokens_str + ["""$A""", """$B"""] + suffix_tokens_str       ,     special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str       ,     self.prefix_tokens + self.suffix_tokens			)			)       ,     )





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str			)			->					None:
										SCREAMING_SNAKE_CASE           =					self.convert_tokens_to_ids(a			)
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[self.eos_token_id, self.cur_lang_code]

										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.prefix_tokens			)
										SCREAMING_SNAKE_CASE           =					self.convert_ids_to_tokens(self.suffix_tokens			)

										SCREAMING_SNAKE_CASE           =					processors.TemplateProcessing(
										    single=prefix_tokens_str + ["""$A"""] + suffix_tokens_str       ,     pair=prefix_tokens_str + ["""$A""", """$B"""] + suffix_tokens_str       ,     special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str       ,     self.prefix_tokens + self.suffix_tokens			)			)       ,     )







							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str       ,     a       :	Optional[str] = None			)			->					Tuple[str]:
										if not self.can_save_slow_tokenizer:
													raise ValueError(
													    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
													    """tokenizer."""			)

										if not os.path.isdir(a			):
													logger.error(f"""Vocabulary path ({save_directory}) should be a directory."""			)
													return
										SCREAMING_SNAKE_CASE           =					os.path.join(
										    a       ,     (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]			)

										if os.path.abspath(self.vocab_file			) != os.path.abspath(a			):
													copyfile(self.vocab_file       ,     a			)

										return (out_vocab_file,)






