

import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_lxmert import LxmertTokenizer


_lowerCamelCase				:   Union[str, Any]					   =							{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

_lowerCamelCase				:   Optional[Any]					   =							{
    "vocab_file": {
        "unc-nlp/lxmert-base-uncased": "https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/vocab.txt",
    },
    "tokenizer_file": {
        "unc-nlp/lxmert-base-uncased": (
            "https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/tokenizer.json"
        ),
    },
}

_lowerCamelCase				:   List[str]					   =							{
    "unc-nlp/lxmert-base-uncased": 5_1_2,
}

_lowerCamelCase				:   Optional[int]					   =							{
    "unc-nlp/lxmert-base-uncased": {"do_lower_case": True},
}





class 					__UpperCAmelCase     (       __A						):
   UpperCamelCase        =     VOCAB_FILES_NAMES
   UpperCamelCase        =     PRETRAINED_VOCAB_FILES_MAP
   UpperCamelCase        =     PRETRAINED_INIT_CONFIGURATION
   UpperCamelCase        =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   UpperCamelCase        =     LxmertTokenizer



   def __init__(							self							:     Union[str, Any],		__A							:     int=None,		__A							:     Optional[Any]=None,		__A							:     Dict=True,		__A							:     Any="[UNK]",		__A							:     Tuple="[SEP]",		__A							:     List[Any]="[PAD]",		__A							:     Union[str, Any]="[CLS]",		__A							:     str="[MASK]",		__A							:     List[str]=True,		__A							:     List[str]=None,		**__A							:     List[str],		):
     super().__init__(
         _UpperCamelCase,		tokenizer_file=_UpperCamelCase,		do_lower_case=_UpperCamelCase,		unk_token=_UpperCamelCase,		sep_token=_UpperCamelCase,		pad_token=_UpperCamelCase,		cls_token=_UpperCamelCase,		mask_token=_UpperCamelCase,		tokenize_chinese_chars=_UpperCamelCase,		strip_accents=_UpperCamelCase,		**_UpperCamelCase,		)

     UpperCAmelCase       :							str  = json.loads(self.backend_tokenizer.normalizer.__getstate__()						)
     if (
         normalizer_state.get('''lowercase''',		_UpperCamelCase						) != do_lower_case
         or normalizer_state.get('''strip_accents''',		_UpperCamelCase						) != strip_accents
         or normalizer_state.get('''handle_chinese_chars''',		_UpperCamelCase						) != tokenize_chinese_chars
     ):
       UpperCAmelCase       :							Any  = getattr(_UpperCamelCase,		normalizer_state.pop('''type'''						)						)
       UpperCAmelCase       :							str  = do_lower_case
       UpperCAmelCase       :							Tuple  = strip_accents
       UpperCAmelCase       :							Union[str, Any]  = tokenize_chinese_chars
       UpperCAmelCase       :							Tuple  = normalizer_class(**_UpperCamelCase						)

     UpperCAmelCase       :							Any  = do_lower_case



   def        __magic_name__    (							self							:     Optional[int],		__A							:     List[Any],		__A							:     List[str]=None						):
     UpperCAmelCase       :							str  = [self.cls_token_id] + token_ids_a + [self.sep_token_id]

     if token_ids_a:
       output += token_ids_a + [self.sep_token_id]

     return output



   def        __magic_name__    (							self							:     int,		__A							:     List[int],		__A							:     Optional[List[int]] = None						):
     UpperCAmelCase       :							int  = [self.sep_token_id]
     UpperCAmelCase       :							Union[str, Any]  = [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						) * [0] + len(token_ids_a + sep						) * [1]





   def        __magic_name__    (							self							:     Any,		__A							:     str,		__A							:     Optional[str] = None						):
     UpperCAmelCase       :							Tuple  = self._tokenizer.model.save(_UpperCamelCase,		name=_UpperCamelCase						)
     return tuple(_UpperCamelCase						)








from sklearn.metrics import mean_squared_error

import datasets


lowerCAmelCase_       	=	'''\
@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_       	=	'''\
Mean Squared Error(MSE) is the average of the square of difference between the predicted
and actual values.
'''


lowerCAmelCase_       	=	'''
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 	snake_case_   (		datasets.Metric					):







			'''simple docstring'''

			def 				snake_case__(     self :				Optional[int]							)      ->List[Any]:
									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 				snake_case__(     self :				List[Any]							)      ->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 				snake_case__(     self :				int							,   _UpperCamelCase :				int							,   _UpperCamelCase :				Union[str, Any]							,   _UpperCamelCase :				Any=None							,   _UpperCamelCase :				Optional[int]="uniform_average"							,   _UpperCamelCase :				Tuple=True							)      ->Tuple:
									snake_case_   =	mean_squared_error(
									    _UpperCamelCase							,   _UpperCamelCase							,   sample_weight=_UpperCamelCase							,   multioutput=_UpperCamelCase							,   squared=_UpperCamelCase							)

									return {"mse": mse}