
from sklearn.metrics import mean_absolute_error

import datasets


_A	  =					"""\
@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	  =					"""\
Mean Absolute Error (MAE) is the mean of the magnitude of difference between the predicted and actual
values.
"""


_A	  =					"""
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 lowerCamelCase_				(      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 lowerCamelCase_				(      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 lowerCamelCase_				(      self     ,	__UpperCamelCase     ,	__UpperCamelCase     ,	__UpperCamelCase=None     ,	__UpperCamelCase="uniform_average"     ):




        """simple docstring"""


        UpperCamelCase_							       =       mean_absolute_error(_snake_case     ,	_snake_case     ,	sample_weight=_snake_case     ,	multioutput=_snake_case     )

        return {"mae": mae_score}





import itertools
from dataclasses import dataclass
from io import StringIO
from typing import Optional

import pyarrow as pa

import datasets
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


_A	  =					datasets.utils.logging.get_logger(__name__)

@dataclass
class 		lowercase_       (       datasets.BuilderConfig				):
 A__						:				Optional[datasets.Features]         =    None
 A__						:				str         =    "utf-8"
 A__						:				Optional[str]         =    None
 A__						:				int         =    10 << 20  # 10MB
 A__						:				bool         =    False
 A__						:				str         =    "line"



class 		lowercase_       (       datasets.ArrowBasedBuilder				):
 A__						:				str         =    TextConfig

 def lowerCamelCase_				(      self     ):




        """simple docstring"""


        return datasets.DatasetInfo(features=self.config.features     )

 def lowerCamelCase_				(      self     ,	__UpperCamelCase     ):




        """simple docstring"""


        if not self.config.data_files:
               raise ValueError(f'''At least one data file must be specified, but got data_files={self.config.data_files}'''     )
        UpperCamelCase_							       =       dl_manager.download_and_extract(self.config.data_files     )
        if isinstance(__UpperCamelCase     ,	(str, list, tuple)     ):
               UpperCamelCase_							       =       data_files
               if isinstance(__UpperCamelCase     ,	__UpperCamelCase     ):
                      UpperCamelCase_							       =       [files]
               UpperCamelCase_							       =       [dl_manager.iter_files(__UpperCamelCase     ) for file in files]
               return [datasets.SplitGenerator(name=datasets.Split.TRAIN     ,	gen_kwargs={"""files""": files}     )]
        UpperCamelCase_							       =       []
        for split_name, files in data_files.items():
               if isinstance(__UpperCamelCase     ,	__UpperCamelCase     ):
                      UpperCamelCase_							       =       [files]
               UpperCamelCase_							       =       [dl_manager.iter_files(__UpperCamelCase     ) for file in files]
               splits.append(datasets.SplitGenerator(name=__UpperCamelCase     ,	gen_kwargs={"""files""": files}     )     )
        return splits

 def lowerCamelCase_				(      self     ,	__UpperCamelCase     ):




        """simple docstring"""


        if self.config.features is not None:
               UpperCamelCase_							       =       self.config.features.arrow_schema
               if all(not require_storage_cast(__UpperCamelCase     ) for feature in self.config.features.values()     ):
                      # cheaper cast
                      UpperCamelCase_							       =       pa_table.cast(__UpperCamelCase     )
               else:
                      # more expensive cast; allows str <-> int/float or str to Audio for example
                      UpperCamelCase_							       =       table_cast(__UpperCamelCase     ,	__UpperCamelCase     )
               return pa_table
        else:
               return pa_table.cast(pa.schema({"""text""": pa.string()}     )     )

 def lowerCamelCase_				(      self     ,	__UpperCamelCase     ):




        """simple docstring"""


        UpperCamelCase_							       =       list(self.config.features     ) if self.config.features is not None else ["""text"""]
        for file_idx, file in enumerate(itertools.chain.from_iterable(__UpperCamelCase     )     ):
               # open in text mode, by default translates universal newlines ("\n", "\r\n" and "\r") into "\n"
               with open(__UpperCamelCase     ,	encoding=self.config.encoding     ,	errors=self.config.errors     ) as f:
                      if self.config.sample_by == "line":
                             UpperCamelCase_							       =       0
                             while True:
                                    UpperCamelCase_							       =       f.read(self.config.chunksize     )
                                    if not batch:
                                           break
                                    batch += f.readline()  # finish current line
                                    # StringIO.readlines, by default splits only on "\n" (and keeps line breaks)
                                    UpperCamelCase_							       =       StringIO(__UpperCamelCase     ).readlines()
                                    if not self.config.keep_linebreaks:
                                           UpperCamelCase_							       =       [line.rstrip("""\n"""     ) for line in batch]
                                    UpperCamelCase_							       =       pa.Table.from_arrays([pa.array(__UpperCamelCase     )]     ,	names=__UpperCamelCase     )
                                    # Uncomment for debugging (will print the Arrow table size and elements)
                                    # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                                    # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                                    yield (file_idx, batch_idx), self._cast_table(__UpperCamelCase     )
                                    batch_idx += 1
                      elif self.config.sample_by == "paragraph":
                             UpperCamelCase_							       =       0
                             UpperCamelCase_							       =       """"""
                             while True:
                                    UpperCamelCase_							       =       f.read(self.config.chunksize     )
                                    if not new_batch:
                                           break
                                    batch += new_batch
                                    batch += f.readline()  # finish current line
                                    UpperCamelCase_							       =       batch.split("""\n\n"""     )
                                    UpperCamelCase_							       =       pa.Table.from_arrays(
                                        [pa.array([example for example in batch[:-1] if example]     )]     ,	names=__UpperCamelCase     )
                                    # Uncomment for debugging (will print the Arrow table size and elements)
                                    # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                                    # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                                    yield (file_idx, batch_idx), self._cast_table(__UpperCamelCase     )
                                    batch_idx += 1
                                    UpperCamelCase_							       =       batch[-1]
                             if batch:
                                    UpperCamelCase_							       =       pa.Table.from_arrays([pa.array([batch]     )]     ,	names=__UpperCamelCase     )
                                    yield (file_idx, batch_idx), self._cast_table(__UpperCamelCase     )
                      elif self.config.sample_by == "document":
                             UpperCamelCase_							       =       f.read()
                             UpperCamelCase_							       =       pa.Table.from_arrays([pa.array([text]     )]     ,	names=__UpperCamelCase     )
                             yield file_idx, self._cast_table(__UpperCamelCase     )



