






from sklearn.metrics import mean_squared_error

import datasets


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

A_						:						List[Any]						      =					'\\nMean Squared Error(MSE) is the average of the square of difference between the predicted\nand actual values.\n'


A_						:						Optional[int]						      =					'\nArgs:\n    predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Estimated target values.\n    references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Ground truth (correct) target values.\n    sample_weight: array-like of shape (n_samples,), default=None\n        Sample weights.\n    multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n        Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n        "raw_values" : Returns a full set of errors in case of multioutput input.\n\n        "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\n    squared : bool, default=True\n        If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.\n\nReturns:\n    mse : mean squared error.\nExamples:\n\n    >>> mse_metric = datasets.load_metric("mse")\n    >>> predictions = [2.5, 0.0, 2, 8]\n    >>> references = [3, -0.5, 2, 7]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.375}\n    >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)\n    >>> print(rmse_result)\n    {\'mse\': 0.6123724356957945}\n\n    If you\'re using multi-dimensional lists, then set the config as follows :\n\n    >>> mse_metric = datasets.load_metric("mse", "multilist")\n    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n    >>> references = [[0, 2], [-1, 2], [8, -5]]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.7083333333333334}\n    >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n    >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n    {\'mse\': array([0.41666667, 1. ])}\n'




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





       """simple docstring"""







       def      _a       (   self				):
         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      _a       (   self				):




         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      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase=None    ,     _lowerCamelCase="uniform_average"    ,     _lowerCamelCase=True				):
         UpperCamelCase_:   Tuple        =							mean_squared_error(
             lowercase_    ,     lowercase_    ,     sample_weight=lowercase_    ,     multioutput=lowercase_    ,     squared=lowercase_				)

         return {"mse": mse}



import pickle
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, XLMRobertaTokenizer, XLMRobertaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


lowerCamelCase		   =			get_tests_dir('fixtures/test_sentencepiece.model')




@require_sentencepiece
@require_tokenizers
class A    (  UpperCamelCase_       ,				unittest.TestCase	):
      UpperCamelCase__				:    List[Any] =XLMRobertaTokenizer
      UpperCamelCase__				:    Union[str, Any] =XLMRobertaTokenizerFast
      UpperCamelCase__				:    int =True
      UpperCamelCase__				:    Optional[Any] =True






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		Dict:
             """simple docstring"""




             super().setUp()

             # We have a SentencePiece fixture for testing
             _lowerCamelCase			:						Dict            =XLMRobertaTokenizer(lowercase_     ,  keep_accents=lowercase_					)
             tokenizer.save_pretrained(self.tmpdirname					)






      def 			lowerCamelCase			(   self		:	Dict					)   ->		Any:
             """simple docstring"""




             _lowerCamelCase			:						Tuple            ='<pad>'
             _lowerCamelCase			:						Optional[int]            =1

             self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowercase_					)     ,  lowercase_					)
             self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowercase_					)     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Any					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						str            =list(self.get_tokenizer().get_vocab().keys()					)

             self.assertEqual(vocab_keys[0]     ,  '<s>'					)
             self.assertEqual(vocab_keys[1]     ,  '<pad>'					)
             self.assertEqual(vocab_keys[-1]     ,  '<mask>'					)
             self.assertEqual(len(lowercase_					)     ,  1002					)






      def 			lowerCamelCase			(   self		:	int					)   ->		Optional[Any]:
             """simple docstring"""




             self.assertEqual(self.get_tokenizer().vocab_size     ,  1002					)






      def 			lowerCamelCase			(   self		:	Tuple					)   ->		Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase			:						Optional[Any]            =XLMRobertaTokenizer(lowercase_     ,  keep_accents=lowercase_					)

             _lowerCamelCase			:						List[Any]            =tokenizer.tokenize('This is a test'					)
             self.assertListEqual(lowercase_     ,  ['▁This', '▁is', '▁a', '▁t', 'est']					)

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

             _lowerCamelCase			:						int            =tokenizer.tokenize('I was born in 92000, and this is falsé.'					)
             self.assertListEqual(
                 lowercase_     ,  [
                     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',
                     'é',
                     '.',
                 ]     ,  )
             _lowerCamelCase			:						Optional[Any]            =tokenizer.convert_tokens_to_ids(lowercase_					)
             self.assertListEqual(
                 lowercase_     ,  [
                     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]
                     #                                       ^ unk: 2 + 1 = 3                  unk: 2 + 1 = 3 ^
                 ]     ,  )

             _lowerCamelCase			:						Optional[Any]            =tokenizer.convert_ids_to_tokens(lowercase_					)
             self.assertListEqual(
                 lowercase_     ,  [
                     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>',
                     '.',
                 ]     ,  )






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		Any:
             """simple docstring"""




             if not self.test_slow_tokenizer:
                    # as we don't have a slow version, we can't compare the outputs between slow and fast versions
                    return

             _lowerCamelCase			:						List[str]            =(self.rust_tokenizer_class, 'hf-internal-testing/tiny-xlm-roberta', {})
             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                    with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
                           _lowerCamelCase			:						int            =self.rust_tokenizer_class.from_pretrained(lowercase_     ,  **lowercase_					)
                           _lowerCamelCase			:						List[Any]            =self.tokenizer_class.from_pretrained(lowercase_     ,  **lowercase_					)

                           _lowerCamelCase			:						int            =tempfile.mkdtemp()

                           _lowerCamelCase			:						List[str]            =tokenizer_r.save_pretrained(lowercase_					)
                           _lowerCamelCase			:						int            =tokenizer_p.save_pretrained(lowercase_					)

                           # Checks it save with the same files + the tokenizer.json file for the fast one
                           self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files					)					)
                           _lowerCamelCase			:						Optional[Any]            =tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f					)
                           self.assertSequenceEqual(lowercase_     ,  lowercase_					)

                           # Checks everything loads correctly in the same way
                           _lowerCamelCase			:						int            =tokenizer_r.from_pretrained(lowercase_					)
                           _lowerCamelCase			:						Any            =tokenizer_p.from_pretrained(lowercase_					)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowercase_     ,  lowercase_					)					)
                                  # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
                                  # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

                           shutil.rmtree(lowercase_					)

                           # Save tokenizer rust, legacy_format=True
                           _lowerCamelCase			:						Dict            =tempfile.mkdtemp()

                           _lowerCamelCase			:						int            =tokenizer_r.save_pretrained(lowercase_     ,  legacy_format=lowercase_					)
                           _lowerCamelCase			:						Optional[Any]            =tokenizer_p.save_pretrained(lowercase_					)

                           # Checks it save with the same files
                           self.assertSequenceEqual(lowercase_     ,  lowercase_					)

                           # Checks everything loads correctly in the same way
                           _lowerCamelCase			:						int            =tokenizer_r.from_pretrained(lowercase_					)
                           _lowerCamelCase			:						List[Any]            =tokenizer_p.from_pretrained(lowercase_					)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowercase_     ,  lowercase_					)					)

                           shutil.rmtree(lowercase_					)

                           # Save tokenizer rust, legacy_format=False
                           _lowerCamelCase			:						str            =tempfile.mkdtemp()

                           _lowerCamelCase			:						Optional[Any]            =tokenizer_r.save_pretrained(lowercase_     ,  legacy_format=lowercase_					)
                           _lowerCamelCase			:						Any            =tokenizer_p.save_pretrained(lowercase_					)

                           # Checks it saved the tokenizer.json file
                           self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files					)					)

                           # Checks everything loads correctly in the same way
                           _lowerCamelCase			:						str            =tokenizer_r.from_pretrained(lowercase_					)
                           _lowerCamelCase			:						List[str]            =tokenizer_p.from_pretrained(lowercase_					)

                           # Check special tokens are set accordingly on Rust and Python
                           for key in tokenizer_pp.special_tokens_map:
                                  self.assertTrue(hasattr(lowercase_     ,  lowercase_					)					)

                           shutil.rmtree(lowercase_					)






      @cached_property
      def 			lowerCamelCase			(   self		:	List[str]					)   ->		List[Any]:
             """simple docstring"""




             return XLMRobertaTokenizer.from_pretrained('xlm-roberta-base'					)






      def 			lowerCamelCase			(   self		:	Tuple					)   ->		Dict:
             """simple docstring"""




             with tempfile.NamedTemporaryFile() as f:
                    shutil.copyfile(lowercase_     ,  f.name					)
                    _lowerCamelCase			:						Union[str, Any]            =XLMRobertaTokenizer(f.name     ,  keep_accents=lowercase_					)
                    _lowerCamelCase			:						Dict            =pickle.dumps(lowercase_					)
             pickle.loads(lowercase_					)






      def 			lowerCamelCase			(   self		:	Dict					)   ->		Union[str, Any]:
             """simple docstring"""




             if not self.test_rust_tokenizer:
                    return

             _lowerCamelCase			:						Any            =self.get_tokenizer()
             _lowerCamelCase			:						Optional[int]            =self.get_rust_tokenizer()

             _lowerCamelCase			:						Tuple            ='I was born in 92000, and this is falsé.'

             _lowerCamelCase			:						Any            =tokenizer.tokenize(lowercase_					)
             _lowerCamelCase			:						List[str]            =rust_tokenizer.tokenize(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						int            =tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             _lowerCamelCase			:						Union[str, Any]            =rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Dict            =self.get_rust_tokenizer()
             _lowerCamelCase			:						Optional[int]            =tokenizer.encode(lowercase_					)
             _lowerCamelCase			:						Optional[Any]            =rust_tokenizer.encode(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)






      @slow
      def 			lowerCamelCase			(   self		:	Optional[int]					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						Optional[Any]            ='Hello World!'
             _lowerCamelCase			:						Union[str, Any]            =[0, 3_5378, 6661, 38, 2]
             # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')  # xlmr.large has same tokenizer
             # xlmr.eval()
             # xlmr.encode(symbols)

             self.assertListEqual(lowercase_     ,  self.big_tokenizer.encode(lowercase_					)					)






      @slow
      def 			lowerCamelCase			(   self		:	Any					)   ->		int:
             """simple docstring"""




             _lowerCamelCase			:						Union[str, Any]            =(
                 'This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'
                 ' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'
             )
             _lowerCamelCase			:						List[str]            =[
                 0,
                 3293,
                 83,
                 10,
                 4552,
                 4989,
                 7986,
                 678,
                 10,
                 5915,
                 111,
                 17_9459,
                 12_4850,
                 4,
                 6044,
                 237,
                 12,
                 6,
                 5,
                 6,
                 4,
                 6780,
                 705,
                 15,
                 1388,
                 44,
                 378,
                 1_0114,
                 711,
                 152,
                 20,
                 6,
                 5,
                 2_2376,
                 642,
                 1221,
                 1_5190,
                 3_4153,
                 450,
                 5608,
                 959,
                 1119,
                 5_7702,
                 136,
                 186,
                 47,
                 1098,
                 2_9367,
                 47,
                 # 4426, # What fairseq tokenizes from "<unk>": "_<"
                 # 3678, # What fairseq tokenizes from "<unk>": "unk"
                 # 2740, # What fairseq tokenizes from "<unk>": ">"
                 3,  # What we tokenize from "<unk>": "<unk>"
                 6,  # Residue from the tokenization: an extra sentencepiece underline
                 4,
                 6044,
                 237,
                 6284,
                 5_0901,
                 528,
                 31,
                 90,
                 34,
                 927,
                 2,
             ]
             # xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')  # xlmr.large has same tokenizer
             # xlmr.eval()
             # xlmr.encode(symbols)

             self.assertListEqual(lowercase_     ,  self.big_tokenizer.encode(lowercase_					)					)






      @slow
      def 			lowerCamelCase			(   self		:	Union[str, Any]					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						List[Any]            ={'input_ids': [[0, 1_1062, 8_2772, 7, 15, 8_2772, 538, 5_1529, 237, 1_7198, 1290, 206, 9, 21_5175, 1314, 136, 1_7198, 1290, 206, 9, 5_6359, 42, 12_2009, 9, 1_6466, 16, 8_7344, 4537, 9, 4717, 7_8381, 6, 15_9958, 7, 15, 2_4480, 618, 4, 527, 2_2693, 5428, 4, 2777, 2_4480, 9874, 4, 4_3523, 594, 4, 803, 1_8392, 3_3189, 18, 4, 4_3523, 2_4447, 1_2399, 100, 2_4955, 8_3658, 9626, 14_4057, 15, 839, 2_2335, 16, 136, 2_4955, 8_3658, 8_3479, 15, 3_9102, 724, 16, 678, 645, 2789, 1328, 4589, 42, 12_2009, 11_5774, 23, 805, 1328, 4_6876, 7, 136, 5_3894, 1940, 4_2227, 4_1159, 1_7721, 823, 425, 4, 2_7512, 9_8722, 206, 136, 5531, 4970, 919, 1_7336, 5, 2], [0, 2_0080, 618, 83, 8_2775, 47, 479, 9, 1517, 73, 5_3894, 333, 8_0581, 11_0117, 1_8811, 5256, 1295, 51, 15_2526, 297, 7986, 390, 12_4416, 538, 3_5431, 214, 98, 1_5044, 2_5737, 136, 7108, 4_3701, 23, 756, 13_5355, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 581, 6_3773, 11_9455, 6, 14_7797, 8_8203, 7, 645, 70, 21, 3285, 1_0269, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
             # fmt: on

             self.tokenizer_integration_test_util(
                 expected_encoding=lowercase_     ,  model_name='xlm-roberta-base'     ,  revision='d9d8a8ea5eb94b1c6654ae9249df7793cd2933d3'     ,  )


