




'''simple docstring'''







import importlib.metadata
import sys

from transformers.testing_utils import TestCasePlus
from transformers.utils.versions import require_version, require_version_core


lowercase			:      Optional[Any]			=					importlib.metadata.version("""numpy""")
lowercase			:      int			=					""".""".join([str(x) for x in sys.version_info[:3]])







class 				_a   (a__  ):





     '''simple docstring'''



     def  snake_case_			(							self       )			->							List[Any]:
          # lt + different version strings
          require_version_core("""numpy<1000.4.5"""       )
          require_version_core("""numpy<1000.4"""       )
          require_version_core("""numpy<1000"""       )

          # le
          require_version_core("""numpy<=1000.4.5"""       )
          require_version_core(F'''numpy<={numpy_ver}'''       )

          # eq
          require_version_core(F'''numpy=={numpy_ver}'''       )

          # ne
          require_version_core("""numpy!=1000.4.5"""       )

          # ge
          require_version_core("""numpy>=1.0"""       )
          require_version_core("""numpy>=1.0.0"""       )
          require_version_core(F'''numpy>={numpy_ver}'''       )

          # gt
          require_version_core("""numpy>1.0.0"""       )

          # mix
          require_version_core("""numpy>1.0.0,<1000"""       )

          # requirement w/o version
          require_version_core("""numpy"""       )

          # unmet requirements due to version conflict
          for req in ["numpy==1.0.0", "numpy>=1000.0.0", F'''numpy<{numpy_ver}''']:
               try:
                    require_version_core(__a       )
               except ImportError as e:
                    self.assertIn(F'''{req} is required'''       ,str(__a       )       )
                    self.assertIn("""but found"""       ,str(__a       )       )

        # unmet requirements due to missing module
          for req in ["numpipypie>1", "numpipypie2"]:
               try:
                    require_version_core(__a       )
               except importlib.metadata.PackageNotFoundError as e:
                    self.assertIn(F'''The \'{req}\' distribution was not found and is required by this application'''       ,str(__a       )       )
                    self.assertIn("""Try: pip install transformers -U"""       ,str(__a       )       )

        # bogus requirements formats:
        # 1. whole thing
          for req in ["numpy??1.0.0", "numpy1.0.0"]:
               try:
                    require_version_core(__a       )
               except ValueError as e:
                    self.assertIn("""requirement needs to be in the pip package format"""       ,str(__a       )       )
        # 2. only operators
          for req in ["numpy=1.0.0", "numpy == 1.00", "numpy<>1.0.0", "numpy><1.00", "numpy>>1.0.0"]:
               try:
                    require_version_core(__a       )
               except ValueError as e:
                    self.assertIn("""need one of """       ,str(__a       )       )







     def  snake_case_			(							self       )			->							Union[str, Any]:
          # matching requirement
          require_version("""python>=3.6.0"""       )

          # not matching requirements
          for req in ["python>9.9.9", "python<3.0.0"]:
               try:
                    require_version_core(__a       )
               except ImportError as e:
                    self.assertIn(F'''{req} is required'''       ,str(__a       )       )
                    self.assertIn(F'''but found python=={python_ver}'''       ,str(__a       )       )









'''simple docstring'''







from sklearn.metrics import mean_absolute_error

import datasets


lowercase			:      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}
}
"""

lowercase			:      Optional[Any]			=					"""\
Mean Absolute Error (MAE) is the mean of the magnitude of difference between the predicted and actual
values.
"""


lowercase			:      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 				_a   (datasets.Metric  ):





     '''simple docstring'''



     def  snake_case_			(							self       )			->							int:
          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  snake_case_			(							self       )			->							Any:
          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       ,__a       ,__a       ,__a=None       ,__a="uniform_average"       )			->							str:
          snake_case :			int					   = mean_absolute_error(__a       ,__a       ,sample_weight=__a       ,multioutput=__a       )

          return {"mae": mae_score}



