

from sklearn.metrics import mean_squared_error

import datasets


lowerCAmelCase							:  Tuple            =						"""\
@article{scikit-learn,
 title={Scikit-learn: Machine Learning in {P}ython},
 author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.
         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.
         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and
         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},
 journal={Journal of Machine Learning Research},
 volume={12},
 pages={2825--2830},
 year={2011}
}
"""

lowerCAmelCase							:  List[str]            =						"""\
Mean Squared Error(MSE) is the average of the square of difference between the predicted
and actual values.
"""


lowerCAmelCase							:  Optional[Any]            =						"""
Args:
    predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)
        Estimated target values.
    references: array-like of shape (n_samples,) or (n_samples, n_outputs)
        Ground truth (correct) target values.
    sample_weight: array-like of shape (n_samples,), default=None
        Sample weights.
    multioutput: {\"raw_values\", \"uniform_average\"} or array-like of shape (n_outputs,), default=\"uniform_average\"
        Defines aggregating of multiple output values. Array-like value defines weights used to average errors.

        \"raw_values\" : Returns a full set of errors in case of multioutput input.

        \"uniform_average\" : Errors of all outputs are averaged with uniform weight.

    squared : bool, default=True
        If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.

Returns:
    mse : mean squared error.
Examples:

    >>> mse_metric = datasets.load_metric(\"mse\")
    >>> predictions = [2.5, 0.0, 2, 8]
    >>> references = [3, -0.5, 2, 7]
    >>> results = mse_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'mse': 0.375}
    >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)
    >>> print(rmse_result)
    {'mse': 0.6123724356957945}

    If you're using multi-dimensional lists, then set the config as follows :

    >>> mse_metric = datasets.load_metric(\"mse\", \"multilist\")
    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]
    >>> references = [[0, 2], [-1, 2], [8, -5]]
    >>> results = mse_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'mse': 0.7083333333333334}
    >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput='raw_values')
    >>> print(results) # doctest: +NORMALIZE_WHITESPACE
    {'mse': array([0.41666667, 1. ])}
"""



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




			"""simple docstring"""







			def 	_SCREAMING_SNAKE_CASE      (			self  :					Tuple):
									return datasets.MetricInfo(
									    description=_DESCRIPTION       ,						citation=_CITATION       ,						inputs_description=_KWARGS_DESCRIPTION       ,						features=datasets.Features(self._get_feature_types())       ,						reference_urls=[
									        "https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html"
									    ]       ,						)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[int]):
									if self.config_name == "multilist":
															return {
															    "predictions": datasets.Sequence(datasets.Value("float")),
															    "references": datasets.Sequence(datasets.Value("float")),
															}
									else:
															return {
															    "predictions": datasets.Value("float"),
															    "references": datasets.Value("float"),
															}




			def 	_SCREAMING_SNAKE_CASE      (			self  :					str       ,						lowerCAmelCase__  :					Any       ,						lowerCAmelCase__  :					List[str]       ,						lowerCAmelCase__  :					Any=None       ,						lowerCAmelCase__  :					Dict="uniform_average"       ,						lowerCAmelCase__  :					Any=True):
									SCREAMING_SNAKE_CASE_:			Any  		=	mean_squared_error(
									    lowerCAmelCase__       ,						lowerCAmelCase__       ,						sample_weight=lowerCAmelCase__       ,						multioutput=lowerCAmelCase__       ,						squared=lowerCAmelCase__)

									return {"mse": mse}









import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, PLBartTokenizer, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


lowerCAmelCase							:  Any            =						get_tests_dir("""fixtures/test_sentencepiece.model""")


if is_torch_available():
						from transformers.models.plbart.modeling_plbart import shift_tokens_right

lowerCAmelCase							:  Optional[Any]            =						50003
lowerCAmelCase							:  List[str]            =						50002



@require_sentencepiece
@require_tokenizers
class   __lowercase    (			UpperCAmelCase_		,	unittest.TestCase     ):




			"""simple docstring"""







			_UpperCAmelCase       :							int      							=					PLBartTokenizer
			_UpperCAmelCase       :							Any      							=					None
			_UpperCAmelCase       :							Optional[Any]      							=					False



			def 	_SCREAMING_SNAKE_CASE      (			self  :					str):
									super().setUp()

									# We have a SentencePiece fixture for testing
									SCREAMING_SNAKE_CASE_:			Tuple  		=	PLBartTokenizer(lowerCAmelCase__       ,						language_codes="base"       ,						keep_accents=lowerCAmelCase__)
									tokenizer.save_pretrained(self.tmpdirname)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					str):
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	PLBartTokenizer(lowerCAmelCase__       ,						language_codes="base"       ,						keep_accents=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_:			Dict  		=	tokenizer.tokenize("This is a test")
									self.assertListEqual(lowerCAmelCase__       ,						["▁This", "▁is", "▁a", "▁t", "est"])

									self.assertListEqual(
									    tokenizer.convert_tokens_to_ids(lowerCAmelCase__)       ,						[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]       ,						)

									SCREAMING_SNAKE_CASE_:			List[Any]  		=	tokenizer.tokenize("I was born in 92000, and this is falsé.")
									self.assertListEqual(
									    lowerCAmelCase__       ,						[
									        SPIECE_UNDERLINE + "I",
									        SPIECE_UNDERLINE + "was",
									        SPIECE_UNDERLINE + "b",
									        "or",
									        "n",
									        SPIECE_UNDERLINE + "in",
									        SPIECE_UNDERLINE + "",
									        "9",
									        "2",
									        "0",
									        "0",
									        "0",
									        ",",
									        SPIECE_UNDERLINE + "and",
									        SPIECE_UNDERLINE + "this",
									        SPIECE_UNDERLINE + "is",
									        SPIECE_UNDERLINE + "f",
									        "al",
									        "s",
									        "é",
									        ".",
									    ]       ,						)
									SCREAMING_SNAKE_CASE_:			str  		=	tokenizer.convert_tokens_to_ids(lowerCAmelCase__)
									self.assertListEqual(
									    lowerCAmelCase__       ,						[
									        value + tokenizer.fairseq_offset
									        for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
									    ]       ,						)

									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	tokenizer.convert_ids_to_tokens(lowerCAmelCase__)
									self.assertListEqual(
									    lowerCAmelCase__       ,						[
									        SPIECE_UNDERLINE + "I",
									        SPIECE_UNDERLINE + "was",
									        SPIECE_UNDERLINE + "b",
									        "or",
									        "n",
									        SPIECE_UNDERLINE + "in",
									        SPIECE_UNDERLINE + "",
									        "<unk>",
									        "2",
									        "0",
									        "0",
									        "0",
									        ",",
									        SPIECE_UNDERLINE + "and",
									        SPIECE_UNDERLINE + "this",
									        SPIECE_UNDERLINE + "is",
									        SPIECE_UNDERLINE + "f",
									        "al",
									        "s",
									        "<unk>",
									        ".",
									    ]       ,						)

									SCREAMING_SNAKE_CASE_:			int  		=	tokenizer.vocab_size
									SCREAMING_SNAKE_CASE_:			Tuple  		=	[tokenizer.convert_ids_to_tokens(lowerCAmelCase__) for x in range(end - 4       ,						lowerCAmelCase__)]

									self.assertListEqual(lowerCAmelCase__       ,						["__java__", "__python__", "__en_XX__", "<mask>"])

									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	"java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	tokenizer(lowerCAmelCase__).input_ids
									self.assertEqual(
									    tokenizer.decode(lowerCAmelCase__       ,						skip_special_tokens=lowerCAmelCase__       ,						clean_up_tokenization_spaces=lowerCAmelCase__)       ,						lowerCAmelCase__       ,						)




			def 	_SCREAMING_SNAKE_CASE      (			self  :					Union[str, Any]):
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	PLBartTokenizer(lowerCAmelCase__       ,						language_codes="multi"       ,						keep_accents=lowerCAmelCase__)

									SCREAMING_SNAKE_CASE_:			str  		=	tokenizer.tokenize("This is a test")
									self.assertListEqual(lowerCAmelCase__       ,						["▁This", "▁is", "▁a", "▁t", "est"])

									self.assertListEqual(
									    tokenizer.convert_tokens_to_ids(lowerCAmelCase__)       ,						[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]       ,						)

									SCREAMING_SNAKE_CASE_:			Tuple  		=	tokenizer.tokenize("I was born in 92000, and this is falsé.")
									self.assertListEqual(
									    lowerCAmelCase__       ,						[
									        SPIECE_UNDERLINE + "I",
									        SPIECE_UNDERLINE + "was",
									        SPIECE_UNDERLINE + "b",
									        "or",
									        "n",
									        SPIECE_UNDERLINE + "in",
									        SPIECE_UNDERLINE + "",
									        "9",
									        "2",
									        "0",
									        "0",
									        "0",
									        ",",
									        SPIECE_UNDERLINE + "and",
									        SPIECE_UNDERLINE + "this",
									        SPIECE_UNDERLINE + "is",
									        SPIECE_UNDERLINE + "f",
									        "al",
									        "s",
									        "é",
									        ".",
									    ]       ,						)
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	tokenizer.convert_tokens_to_ids(lowerCAmelCase__)
									self.assertListEqual(
									    lowerCAmelCase__       ,						[
									        value + tokenizer.fairseq_offset
									        for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
									    ]       ,						)

									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	tokenizer.convert_ids_to_tokens(lowerCAmelCase__)
									self.assertListEqual(
									    lowerCAmelCase__       ,						[
									        SPIECE_UNDERLINE + "I",
									        SPIECE_UNDERLINE + "was",
									        SPIECE_UNDERLINE + "b",
									        "or",
									        "n",
									        SPIECE_UNDERLINE + "in",
									        SPIECE_UNDERLINE + "",
									        "<unk>",
									        "2",
									        "0",
									        "0",
									        "0",
									        ",",
									        SPIECE_UNDERLINE + "and",
									        SPIECE_UNDERLINE + "this",
									        SPIECE_UNDERLINE + "is",
									        SPIECE_UNDERLINE + "f",
									        "al",
									        "s",
									        "<unk>",
									        ".",
									    ]       ,						)
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	tokenizer.vocab_size
									SCREAMING_SNAKE_CASE_:			int  		=	[tokenizer.convert_ids_to_tokens(lowerCAmelCase__) for x in range(end - 7       ,						lowerCAmelCase__)]

									self.assertListEqual(
									    lowerCAmelCase__       ,						["__java__", "__python__", "__en_XX__", "__javascript__", "__php__", "__ruby__", "__go__"])
									SCREAMING_SNAKE_CASE_:			str  		=	"java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"
									SCREAMING_SNAKE_CASE_:			Tuple  		=	tokenizer(lowerCAmelCase__).input_ids
									self.assertEqual(
									    tokenizer.decode(lowerCAmelCase__       ,						skip_special_tokens=lowerCAmelCase__       ,						clean_up_tokenization_spaces=lowerCAmelCase__)       ,						lowerCAmelCase__       ,						)







@require_torch
@require_sentencepiece
@require_tokenizers
class   __lowercase    (			unittest.TestCase     ):




			"""simple docstring"""







			_UpperCAmelCase       :							Optional[Any]      							=					'''uclanlp/plbart-python-en_XX'''
			_UpperCAmelCase       :							List[str]      							=					[
			    '''def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])''',
			    '''def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])''',
			]
			_UpperCAmelCase       :							int      							=					[
			    '''Returns the maximum value of a b c.''',
			    '''Sums the values of a b c.''',
			]
			_UpperCAmelCase       :							Optional[Any]      							=					[
			    134,
			    5452,
			    3_3460,
			    3_3441,
			    3_3463,
			    3_3465,
			    3_3463,
			    3_3449,
			    988,
			    20,
			    3_3456,
			    19,
			    3_3456,
			    771,
			    39,
			    4258,
			    889,
			    3318,
			    3_3441,
			    3_3463,
			    3_3465,
			    3_3463,
			    3_3449,
			    2471,
			    2,
			    PYTHON_CODE,
			]



			@classmethod
			def 	_SCREAMING_SNAKE_CASE      (			cls  :					Dict):
									SCREAMING_SNAKE_CASE_:			PLBartTokenizer  		=	PLBartTokenizer.from_pretrained(
									    cls.checkpoint_name       ,						language_codes="base"       ,						src_lang="python"       ,						tgt_lang="en_XX")
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	1
									return cls



			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[str]):
									self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__java__"]       ,						5_0001)
									self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__python__"]       ,						5_0002)
									self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__en_XX__"]       ,						5_0003)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[Any]):
									SCREAMING_SNAKE_CASE_:			Dict  		=	self.tokenizer.batch_encode_plus(self.src_text).input_ids[0]
									self.assertListEqual(self.expected_src_tokens       ,						lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Dict):
									self.assertIn(lowerCAmelCase__       ,						self.tokenizer.all_special_ids)
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	[EN_CODE, 9037, 3_3442, 57, 752, 153, 14, 56, 18, 9, 2]
									SCREAMING_SNAKE_CASE_:			int  		=	self.tokenizer.decode(lowerCAmelCase__       ,						skip_special_tokens=lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	self.tokenizer.decode(generated_ids[1:]       ,						skip_special_tokens=lowerCAmelCase__)
									self.assertEqual(lowerCAmelCase__       ,						lowerCAmelCase__)
									self.assertNotIn(self.tokenizer.eos_token       ,						lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					str):
									SCREAMING_SNAKE_CASE_:			List[str]  		=	["def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])" * 20]
									self.assertIsInstance(src_text[0]       ,						lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	10
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	self.tokenizer(lowerCAmelCase__       ,						max_length=lowerCAmelCase__       ,						truncation=lowerCAmelCase__).input_ids[0]
									self.assertEqual(ids[-2]       ,						2)
									self.assertEqual(ids[-1]       ,						lowerCAmelCase__)
									self.assertEqual(len(lowerCAmelCase__)       ,						lowerCAmelCase__)



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Tuple):
									self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "__java__"])       ,						[5_0004, 5_0001])



			def 	_SCREAMING_SNAKE_CASE      (			self  :					str):
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	tempfile.mkdtemp()
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	self.tokenizer.fairseq_tokens_to_ids
									self.tokenizer.save_pretrained(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			int  		=	PLBartTokenizer.from_pretrained(lowerCAmelCase__)
									self.assertDictEqual(new_tok.fairseq_tokens_to_ids       ,						lowerCAmelCase__)



			@require_torch
			def 	_SCREAMING_SNAKE_CASE      (			self  :					int):
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	self.tokenizer(self.src_text       ,						text_target=self.tgt_text       ,						padding=lowerCAmelCase__       ,						return_tensors="pt")
									SCREAMING_SNAKE_CASE_:			Any  		=	shift_tokens_right(batch["labels"]       ,						self.tokenizer.pad_token_id)

									# fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
									self.assertEqual(batch.input_ids[1][-2:].tolist()       ,						[2, PYTHON_CODE])
									self.assertEqual(batch.decoder_input_ids[1][0]       ,						lowerCAmelCase__)
									self.assertEqual(batch.decoder_input_ids[1][-1]       ,						2)
									self.assertEqual(batch.labels[1][-2:].tolist()       ,						[2, EN_CODE])



			@require_torch
			def 	_SCREAMING_SNAKE_CASE      (			self  :					str):
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	self.tokenizer(
									    self.src_text       ,						text_target=self.tgt_text       ,						padding=lowerCAmelCase__       ,						truncation=lowerCAmelCase__       ,						max_length=len(self.expected_src_tokens)       ,						return_tensors="pt"       ,						)
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	shift_tokens_right(batch["labels"]       ,						self.tokenizer.pad_token_id)

									self.assertIsInstance(lowerCAmelCase__       ,						lowerCAmelCase__)

									self.assertEqual((2, 26)       ,						batch.input_ids.shape)
									self.assertEqual((2, 26)       ,						batch.attention_mask.shape)
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	batch.input_ids.tolist()[0]
									self.assertListEqual(self.expected_src_tokens       ,						lowerCAmelCase__)
									self.assertEqual(2       ,						batch.decoder_input_ids[0, -1])  # EOS
									# Test that special tokens are reset
									self.assertEqual(self.tokenizer.prefix_tokens       ,						[])
									self.assertEqual(self.tokenizer.suffix_tokens       ,						[self.tokenizer.eos_token_id, PYTHON_CODE])



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[Any]):
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	self.tokenizer(self.src_text       ,						padding=lowerCAmelCase__       ,						truncation=lowerCAmelCase__       ,						max_length=3       ,						return_tensors="pt")
									SCREAMING_SNAKE_CASE_:			Any  		=	self.tokenizer(
									    text_target=self.tgt_text       ,						padding=lowerCAmelCase__       ,						truncation=lowerCAmelCase__       ,						max_length=10       ,						return_tensors="pt")
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	targets["input_ids"]
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	shift_tokens_right(lowerCAmelCase__       ,						self.tokenizer.pad_token_id)

									self.assertEqual(batch.input_ids.shape[1]       ,						3)
									self.assertEqual(batch.decoder_input_ids.shape[1]       ,						10)




			@require_torch
			def 	_SCREAMING_SNAKE_CASE      (			self  :					int):
									SCREAMING_SNAKE_CASE_:			List[str]  		=	self.tokenizer._build_translation_inputs(
									    "A test"       ,						return_tensors="pt"       ,						src_lang="en_XX"       ,						tgt_lang="java")

									self.assertEqual(
									    nested_simplify(lowerCAmelCase__)       ,						{
									        # A, test, EOS, en_XX
									        "input_ids": [[150, 242, 2, 5_0003]],
									        "attention_mask": [[1, 1, 1, 1]],
									        # java
									        "forced_bos_token_id": 5_0001,
									    }       ,						)






