





"""simple docstring"""


from sklearn.metrics import mean_absolute_error

import datasets


a__       :  Optional[int]       		=					"""\
@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}
}
"""

a__       :  Tuple       		=					"""\
Mean Absolute Error (MAE) is the mean of the magnitude of difference between the predicted and actual
values.
"""


a__       :  List[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.

Returns:
    mae : mean absolute error.
        If multioutput is \"raw_values\", then mean absolute error is returned for each output separately. If multioutput is \"uniform_average\" or an ndarray of weights, then the weighted average of all output errors is returned.
        MAE output is non-negative floating point. The best value is 0.0.
Examples:

    >>> mae_metric = datasets.load_metric(\"mae\")
    >>> predictions = [2.5, 0.0, 2, 8]
    >>> references = [3, -0.5, 2, 7]
    >>> results = mae_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'mae': 0.5}

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

    >>> mae_metric = datasets.load_metric(\"mae\", \"multilist\")
    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]
    >>> references = [[0, 2], [-1, 2], [8, -5]]
    >>> results = mae_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'mae': 0.75}
    >>> results = mae_metric.compute(predictions=predictions, references=references, multioutput='raw_values')
    >>> print(results)
    {'mae': array([0.5, 1. ])}
"""



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

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''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_absolute_error.html"
            ] ,       )

       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''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 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE=None ,       __SCREAMING_SNAKE_CASE="uniform_average"  ):






        '''simple docstring'''

        snake_case__     				=					mean_absolute_error(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       sample_weight=__SCREAMING_SNAKE_CASE ,       multioutput=__SCREAMING_SNAKE_CASE  )

        return {"mae": mae_score}








"""simple docstring"""


import os
import warnings
from pathlib import Path
from typing import Optional, Union

from .dynamic_module_utils import custom_object_save
from .tokenization_utils_base import PreTrainedTokenizerBase
from .utils import PushToHubMixin, copy_func, direct_transformers_import, logging


a__       :  Any       		=					logging.get_logger(__name__)

# Dynamically import the Transformers module to grab the attribute classes of the processor form their names.
a__       :  List[Any]       		=					direct_transformers_import(Path(__file__).parent)


a__       :  Optional[Any]       		=					{
    """AutoTokenizer""": """PreTrainedTokenizerBase""",
    """AutoFeatureExtractor""": """FeatureExtractionMixin""",
    """AutoImageProcessor""": """ImageProcessingMixin""",
}



class   lowercase_					(  __lowerCAmelCase				):
       snake_case__					:				Tuple									=  ["""feature_extractor""", """tokenizer"""]
       # Names need to be attr_class for attr in attributes
       snake_case__					:				Tuple									=  None
       snake_case__					:				Dict									=  None
       snake_case__					:				int									=  None

       def __init__(      self ,       *__SCREAMING_SNAKE_CASE ,       **__SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        for key in kwargs:
         if key not in self.attributes:
          raise TypeError(F"Unexpected keyword argument {key}."  )
        for arg, attribute_name in zip(__SCREAMING_SNAKE_CASE ,       self.attributes  ):
         if attribute_name in kwargs:
          raise TypeError(F"Got multiple values for argument {attribute_name}."  )
         else:
          snake_case__     				=					arg

        if len(__SCREAMING_SNAKE_CASE  ) != len(self.attributes  ):
         raise ValueError(
             F"This processor requires {len(self.attributes  )} arguments: {', '.join(self.attributes  )}. Got "
             F"{len(__SCREAMING_SNAKE_CASE  )} arguments instead."  )

        # Check each arg is of the proper class (this will also catch a user initializing in the wrong order)
        for attribute_name, arg in kwargs.items():
         snake_case__     				=					getattr(self ,       F"{attribute_name}_class"  )
         # Nothing is ever going to be an instance of "AutoXxx", in that case we check the base class.
         snake_case__     				=					AUTO_TO_BASE_CLASS_MAPPING.get(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )
         if isinstance(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):
          snake_case__     				=					tuple(getattr(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ) for n in class_name if n is not None  )
         else:
          snake_case__     				=					getattr(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )

         if not isinstance(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):
          raise ValueError(
              F"Received a {type(__SCREAMING_SNAKE_CASE  ).__name__} for argument {attribute_name}, but a {class_name} was expected."  )

         setattr(self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )

       def __repr__(      self  ):






        '''simple docstring'''

        snake_case__     				=					[F"- {name}: {repr(getattr(self ,       __SCREAMING_SNAKE_CASE  )  )}" for name in self.attributes]
        snake_case__     				=					"\n".join(__SCREAMING_SNAKE_CASE  )
        return F"{self.__class__.__name__}:\n{attributes_repr}"

       def 		_SCREAMING_SNAKE_CASE(      self ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE = False ,       **__SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        os.makedirs(__SCREAMING_SNAKE_CASE ,       exist_ok=__SCREAMING_SNAKE_CASE  )

        if push_to_hub:
         snake_case__     				=					kwargs.pop("commit_message" ,       __SCREAMING_SNAKE_CASE  )
         snake_case__     				=					kwargs.pop("repo_id" ,       save_directory.split(os.path.sep  )[-1]  )
         snake_case__     				=					self._create_repo(__SCREAMING_SNAKE_CASE ,       **__SCREAMING_SNAKE_CASE  )
         snake_case__     				=					self._get_files_timestamps(__SCREAMING_SNAKE_CASE  )
        # If we have a custom config, we copy the file defining it in the folder and set the attributes so it can be
        # loaded from the Hub.
        if self._auto_class is not None:
         snake_case__     				=					[getattr(self ,       __SCREAMING_SNAKE_CASE  ) for attribute_name in self.attributes]
         snake_case__     				=					[(a.init_kwargs if isinstance(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ) else a) for a in attrs]
         custom_object_save(self ,       __SCREAMING_SNAKE_CASE ,       config=__SCREAMING_SNAKE_CASE  )

        for attribute_name in self.attributes:
         snake_case__     				=					getattr(self ,       __SCREAMING_SNAKE_CASE  )
         # Include the processor class in the attribute config so this processor can then be reloaded with the
         # `AutoProcessor` API.
         if hasattr(__SCREAMING_SNAKE_CASE ,       "_set_processor_class"  ):
          attribute._set_processor_class(self.__class__.__name__  )
         attribute.save_pretrained(__SCREAMING_SNAKE_CASE  )

        if self._auto_class is not None:
         # We added an attribute to the init_kwargs of the tokenizers, which needs to be cleaned up.
         for attribute_name in self.attributes:
          snake_case__     				=					getattr(self ,       __SCREAMING_SNAKE_CASE  )
          if isinstance(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):
           del attribute.init_kwargs["auto_map"]

        if push_to_hub:
         self._upload_modified_files(
             __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE ,       commit_message=__SCREAMING_SNAKE_CASE ,       token=kwargs.get("use_auth_token"  ) ,       )

       @classmethod
       def 		_SCREAMING_SNAKE_CASE(      cls ,       __SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE = None ,       __SCREAMING_SNAKE_CASE = False ,       __SCREAMING_SNAKE_CASE = False ,       __SCREAMING_SNAKE_CASE = None ,       __SCREAMING_SNAKE_CASE = "main" ,       **__SCREAMING_SNAKE_CASE ,       ):






        '''simple docstring'''

        snake_case__     				=					cache_dir
        snake_case__     				=					force_download
        snake_case__     				=					local_files_only
        snake_case__     				=					revision

        snake_case__     				=					kwargs.pop("use_auth_token" ,       __SCREAMING_SNAKE_CASE  )
        if use_auth_token is not None:
         warnings.warn(
             "The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers." ,       __SCREAMING_SNAKE_CASE  )
         if token is not None:
          raise ValueError(
              "`token` and `use_auth_token` are both specified. Please set only the argument `token`."  )
         snake_case__     				=					use_auth_token

        if token is not None:
         # change to `token` in a follow-up PR
         snake_case__     				=					token

        snake_case__     				=					cls._get_arguments_from_pretrained(__SCREAMING_SNAKE_CASE ,       **__SCREAMING_SNAKE_CASE  )
        return cls(*__SCREAMING_SNAKE_CASE  )

       @classmethod
       def 		_SCREAMING_SNAKE_CASE(      cls ,       __SCREAMING_SNAKE_CASE="AutoProcessor"  ):






        '''simple docstring'''

        if not isinstance(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):
         snake_case__     				=					auto_class.__name__

        import transformers.models.auto as auto_module

        if not hasattr(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):
         raise ValueError(F"{auto_class} is not a valid auto class."  )

        snake_case__     				=					auto_class

       @classmethod
       def 		_SCREAMING_SNAKE_CASE(      cls ,       __SCREAMING_SNAKE_CASE ,       **__SCREAMING_SNAKE_CASE  ):






        '''simple docstring'''

        snake_case__     				=					[]
        for attribute_name in cls.attributes:
         snake_case__     				=					getattr(cls ,       F"{attribute_name}_class"  )
         if isinstance(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ):
          snake_case__     				=					tuple(getattr(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  ) if n is not None else None for n in class_name  )
          snake_case__     				=					kwargs.get("use_fast" ,       __SCREAMING_SNAKE_CASE  )
          if use_fast and classes[1] is not None:
           snake_case__     				=					classes[1]
          else:
           snake_case__     				=					classes[0]
         else:
          snake_case__     				=					getattr(__SCREAMING_SNAKE_CASE ,       __SCREAMING_SNAKE_CASE  )

         args.append(attribute_class.from_pretrained(__SCREAMING_SNAKE_CASE ,       **__SCREAMING_SNAKE_CASE  )  )
        return args

       @property
       def 		_SCREAMING_SNAKE_CASE(      self  ):






        '''simple docstring'''

        snake_case__     				=					getattr(self ,       self.attributes[0]  )
        return getattr(__SCREAMING_SNAKE_CASE ,       "model_input_names" ,       __SCREAMING_SNAKE_CASE  )
a__       :  Dict       		=					copy_func(ProcessorMixin.push_to_hub)
if ProcessorMixin.push_to_hub.__doc__ is not None:
   a__       :  Any       		=					ProcessorMixin.push_to_hub.__doc__.format(
       object="""processor""", object_class="""AutoProcessor""", object_files="""processor files"""
   )

