




'''simple docstring'''


from sklearn.metrics import mean_squared_error

import datasets


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

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


lowerCAmelCase_      :  Union[str, Any]				     =  '\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      SCREAMING_SNAKE_CASE    (						datasets.Metric				):






      def 							lowercase_						( self   :  Any       ):


           '''simple docstring'''

           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 							lowercase_						( self   :  Any       ):


           '''simple docstring'''

           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 							lowercase_						( self   :  Any						,						lowercase__   :  List[Any]						,						lowercase__   :  Any						,						lowercase__   :  Union[str, Any]=None						,						lowercase__   :  str="uniform_average"						,						lowercase__   :  Tuple=True       ):


           '''simple docstring'''

           a_     :							Dict     						=  mean_squared_error(
               lowercase__						,						lowercase__						,						sample_weight=lowercase__						,						multioutput=lowercase__						,						squared=lowercase__       )

           return {"mse": mse}






'''simple docstring'''


import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_roberta import RobertaTokenizer


lowerCAmelCase_      :  Optional[Any]				     =  logging.get_logger(__name__)

lowerCAmelCase_      :  int				     =  {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}

lowerCAmelCase_      :  Union[str, Any]				     =  {
    'vocab_file': {
        'roberta-base': 'https://huggingface.co/roberta-base/resolve/main/vocab.json',
        'roberta-large': 'https://huggingface.co/roberta-large/resolve/main/vocab.json',
        'roberta-large-mnli': 'https://huggingface.co/roberta-large-mnli/resolve/main/vocab.json',
        'distilroberta-base': 'https://huggingface.co/distilroberta-base/resolve/main/vocab.json',
        'roberta-base-openai-detector': 'https://huggingface.co/roberta-base-openai-detector/resolve/main/vocab.json',
        'roberta-large-openai-detector': (
            'https://huggingface.co/roberta-large-openai-detector/resolve/main/vocab.json'
        ),
    },
    'merges_file': {
        'roberta-base': 'https://huggingface.co/roberta-base/resolve/main/merges.txt',
        'roberta-large': 'https://huggingface.co/roberta-large/resolve/main/merges.txt',
        'roberta-large-mnli': 'https://huggingface.co/roberta-large-mnli/resolve/main/merges.txt',
        'distilroberta-base': 'https://huggingface.co/distilroberta-base/resolve/main/merges.txt',
        'roberta-base-openai-detector': 'https://huggingface.co/roberta-base-openai-detector/resolve/main/merges.txt',
        'roberta-large-openai-detector': (
            'https://huggingface.co/roberta-large-openai-detector/resolve/main/merges.txt'
        ),
    },
    'tokenizer_file': {
        'roberta-base': 'https://huggingface.co/roberta-base/resolve/main/tokenizer.json',
        'roberta-large': 'https://huggingface.co/roberta-large/resolve/main/tokenizer.json',
        'roberta-large-mnli': 'https://huggingface.co/roberta-large-mnli/resolve/main/tokenizer.json',
        'distilroberta-base': 'https://huggingface.co/distilroberta-base/resolve/main/tokenizer.json',
        'roberta-base-openai-detector': (
            'https://huggingface.co/roberta-base-openai-detector/resolve/main/tokenizer.json'
        ),
        'roberta-large-openai-detector': (
            'https://huggingface.co/roberta-large-openai-detector/resolve/main/tokenizer.json'
        ),
    },
}

lowerCAmelCase_      :  Union[str, Any]				     =  {
    'roberta-base': 512,
    'roberta-large': 512,
    'roberta-large-mnli': 512,
    'distilroberta-base': 512,
    'roberta-base-openai-detector': 512,
    'roberta-large-openai-detector': 512,
}







class      SCREAMING_SNAKE_CASE    (						snake_case_				):
      __magic_name__  :       int   							=					VOCAB_FILES_NAMES
      __magic_name__  :       List[str]   							=					PRETRAINED_VOCAB_FILES_MAP
      __magic_name__  :       str   							=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      __magic_name__  :       List[str]   							=					['''input_ids''', '''attention_mask''']
      __magic_name__  :       Any   							=					RobertaTokenizer






      def __init__( self   :  Any						,						lowercase__   :  int=None						,						lowercase__   :  Union[str, Any]=None						,						lowercase__   :  List[Any]=None						,						lowercase__   :  int="replace"						,						lowercase__   :  Dict="<s>"						,						lowercase__   :  int="</s>"						,						lowercase__   :  Optional[Any]="</s>"						,						lowercase__   :  List[Any]="<s>"						,						lowercase__   :  Optional[int]="<unk>"						,						lowercase__   :  Tuple="<pad>"						,						lowercase__   :  Optional[Any]="<mask>"						,						lowercase__   :  List[Any]=False						,						lowercase__   :  Optional[Any]=True						,						**lowercase__   :  List[str]						,						):


           '''simple docstring'''

           super().__init__(
               lowercase__						,						lowercase__						,						tokenizer_file=lowercase__						,						errors=lowercase__						,						bos_token=lowercase__						,						eos_token=lowercase__						,						sep_token=lowercase__						,						cls_token=lowercase__						,						unk_token=lowercase__						,						pad_token=lowercase__						,						mask_token=lowercase__						,						add_prefix_space=lowercase__						,						trim_offsets=lowercase__						,						**lowercase__						,						)

           a_     :							Any     						=  json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()       )
           if pre_tok_state.get("""add_prefix_space"""						,						lowercase__       ) != add_prefix_space:
                a_     :							List[Any]     						=  getattr(lowercase__						,						pre_tok_state.pop("""type"""       )       )
                a_     :							Optional[Any]     						=  add_prefix_space
                a_     :							List[str]     						=  pre_tok_class(**lowercase__       )

           a_     :							List[Any]     						=  add_prefix_space

           a_     :							Any     						=  """post_processor"""
           a_     :							Dict     						=  getattr(self.backend_tokenizer						,						lowercase__						,						lowercase__       )
           if tokenizer_component_instance:
                a_     :							Optional[Any]     						=  json.loads(tokenizer_component_instance.__getstate__()       )

                # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
                if "sep" in state:
                     a_     :							Dict     						=  tuple(state["""sep"""]       )
                if "cls" in state:
                     a_     :							List[str]     						=  tuple(state["""cls"""]       )

                a_     :							str     						=  False

                if state.get("""add_prefix_space"""						,						lowercase__       ) != add_prefix_space:
                     a_     :							Any     						=  add_prefix_space
                     a_     :							List[str]     						=  True

                if state.get("""trim_offsets"""						,						lowercase__       ) != trim_offsets:
                     a_     :							Optional[int]     						=  trim_offsets
                     a_     :							Tuple     						=  True

                if changes_to_apply:
                     a_     :							str     						=  getattr(lowercase__						,						state.pop("""type"""       )       )
                     a_     :							Union[str, Any]     						=  component_class(**lowercase__       )
                     setattr(self.backend_tokenizer						,						lowercase__						,						lowercase__       )






      @property
      def 							lowercase_						( self   :  List[str]       ):


           '''simple docstring'''

           if self._mask_token is None:
                if self.verbose:
                     logger.error("""Using mask_token, but it is not set yet."""       )
                return None
           return str(self._mask_token       )






      @mask_token.setter
      def 							lowercase_						( self   :  Union[str, Any]						,						lowercase__   :  Tuple       ):


           '''simple docstring'''

           a_     :							List[Any]     						=  AddedToken(lowercase__						,						lstrip=lowercase__						,						rstrip=lowercase__       ) if isinstance(lowercase__						,						lowercase__       ) else value
           a_     :							Union[str, Any]     						=  value






      def 							lowercase_						( self   :  Union[str, Any]						,						*lowercase__   :  Union[str, Any]						,						**lowercase__   :  Union[str, Any]       ):


           '''simple docstring'''

           a_     :							Any     						=  kwargs.get("""is_split_into_words"""						,						lowercase__       )
           assert self.add_prefix_space or not is_split_into_words, (
               F"You need to instantiate {self.__class__.__name__} with add_prefix_space=True "
               "to use it with pretokenized inputs."
           )

           return super()._batch_encode_plus(*lowercase__						,						**lowercase__       )






      def 							lowercase_						( self   :  Dict						,						*lowercase__   :  int						,						**lowercase__   :  Dict       ):


           '''simple docstring'''

           a_     :							Any     						=  kwargs.get("""is_split_into_words"""						,						lowercase__       )

           assert self.add_prefix_space or not is_split_into_words, (
               F"You need to instantiate {self.__class__.__name__} with add_prefix_space=True "
               "to use it with pretokenized inputs."
           )

           return super()._encode_plus(*lowercase__						,						**lowercase__       )






      def 							lowercase_						( self   :  Dict						,						lowercase__   :  str						,						lowercase__   :  Optional[str] = None       ):


           '''simple docstring'''

           a_     :							str     						=  self._tokenizer.model.save(lowercase__						,						name=lowercase__       )
           return tuple(lowercase__       )






      def 							lowercase_						( self   :  Dict						,						lowercase__   :  List[Any]						,						lowercase__   :  int=None       ):


           '''simple docstring'''

           a_     :							int     						=  [self.bos_token_id] + token_ids_a + [self.eos_token_id]
           if token_ids_a is None:
                return output

           return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]






      def 							lowercase_						( self   :  List[str]						,						lowercase__   :  List[int]						,						lowercase__   :  Optional[List[int]] = None       ):


           '''simple docstring'''

           a_     :							Optional[Any]     						=  [self.sep_token_id]
           a_     :							Optional[int]     						=  [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]
