






"""simple docstring"""
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import ViTImageProcessor



class 		a_      (	unittest.TestCase ):







      '''simple docstring'''

      def __init__(self,     lowerCamelCase_,     lowerCamelCase_=7,     lowerCamelCase_=3,     lowerCamelCase_=1_8,     lowerCamelCase_=3_0,     lowerCamelCase_=4_0_0,     lowerCamelCase_=True,     lowerCamelCase_=None,     lowerCamelCase_=True,     lowerCamelCase_=[0.5, 0.5, 0.5],     lowerCamelCase_=[0.5, 0.5, 0.5],     ):

       '''simple docstring'''



       lowerCamelCase__     :			str     				=						size if size is not None else {'height': 1_8, 'width': 1_8}
       lowerCamelCase__     :			Any     				=						parent
       lowerCamelCase__     :			Union[str, Any]     				=						batch_size
       lowerCamelCase__     :			Optional[Any]     				=						num_channels
       lowerCamelCase__     :			Tuple     				=						image_size
       lowerCamelCase__     :			Dict     				=						min_resolution
       lowerCamelCase__     :			Any     				=						max_resolution
       lowerCamelCase__     :			Optional[int]     				=						do_resize
       lowerCamelCase__     :			Union[str, Any]     				=						size
       lowerCamelCase__     :			str     				=						do_normalize
       lowerCamelCase__     :			List[str]     				=						image_mean
       lowerCamelCase__     :			Union[str, Any]     				=						image_std





      def 			a__							(self					):

       '''simple docstring'''



       return {
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_normalize": self.do_normalize,
           "do_resize": self.do_resize,
           "size": self.size,
       }



@require_torch
@require_vision
class 		a_      (	snake_case_  ,						unittest.TestCase ):







      '''simple docstring'''

      lowerCamelCase__       :				Any =	ViTImageProcessor if is_vision_available() else None




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			int     				=						ViTImageProcessingTester(self					)




      @property
      def 			a__							(self					):

       '''simple docstring'''



       return self.image_processor_tester.prepare_image_processor_dict()




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Any     				=						self.image_processing_class(**self.image_processor_dict					)
       self.assertTrue(hasattr(lowerCamelCase_,     'image_mean'					)					)
       self.assertTrue(hasattr(lowerCamelCase_,     'image_std'					)					)
       self.assertTrue(hasattr(lowerCamelCase_,     'do_normalize'					)					)
       self.assertTrue(hasattr(lowerCamelCase_,     'do_resize'					)					)
       self.assertTrue(hasattr(lowerCamelCase_,     'size'					)					)




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			List[str]     				=						self.image_processing_class.from_dict(self.image_processor_dict					)
       self.assertEqual(image_processor.size,     {'height': 1_8, 'width': 1_8}					)

       lowerCamelCase__     :			Optional[Any]     				=						self.image_processing_class.from_dict(self.image_processor_dict,     size=4_2					)
       self.assertEqual(image_processor.size,     {'height': 4_2, 'width': 4_2}					)




      def 			a__							(self					):

       '''simple docstring'''



       pass




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Union[str, Any]     				=						self.image_processing_class(**self.image_processor_dict					)
       # create random PIL images
       lowerCamelCase__     :			Dict     				=						prepare_image_inputs(self.image_processor_tester,     equal_resolution=lowerCamelCase_					)
       for image in image_inputs:
        self.assertIsInstance(lowerCamelCase_,     Image.Image					)

       # Test not batched input
       lowerCamelCase__     :			Union[str, Any]     				=						image_processing(image_inputs[0],     return_tensors='pt'					).pixel_values
       self.assertEqual(
           encoded_images.shape,     (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['height'],
               self.image_processor_tester.size['width'],
           ),     )

       # Test batched
       lowerCamelCase__     :			int     				=						image_processing(lowerCamelCase_,     return_tensors='pt'					).pixel_values
       self.assertEqual(
           encoded_images.shape,     (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['height'],
               self.image_processor_tester.size['width'],
           ),     )




      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			List[Any]     				=						self.image_processing_class(**self.image_processor_dict					)
       # create random numpy tensors
       lowerCamelCase__     :			Tuple     				=						prepare_image_inputs(self.image_processor_tester,     equal_resolution=lowerCamelCase_,     numpify=lowerCamelCase_					)
       for image in image_inputs:
        self.assertIsInstance(lowerCamelCase_,     np.ndarray					)

       # Test not batched input
       lowerCamelCase__     :			List[Any]     				=						image_processing(image_inputs[0],     return_tensors='pt'					).pixel_values
       self.assertEqual(
           encoded_images.shape,     (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['height'],
               self.image_processor_tester.size['width'],
           ),     )

       # Test batched
       lowerCamelCase__     :			Dict     				=						image_processing(lowerCamelCase_,     return_tensors='pt'					).pixel_values
       self.assertEqual(
           encoded_images.shape,     (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['height'],
               self.image_processor_tester.size['width'],
           ),     )





      def 			a__							(self					):

       '''simple docstring'''



       lowerCamelCase__     :			Union[str, Any]     				=						self.image_processing_class(**self.image_processor_dict					)
       # create random PyTorch tensors
       lowerCamelCase__     :			Dict     				=						prepare_image_inputs(self.image_processor_tester,     equal_resolution=lowerCamelCase_,     torchify=lowerCamelCase_					)
       for image in image_inputs:
        self.assertIsInstance(lowerCamelCase_,     torch.Tensor					)

       # Test not batched input
       lowerCamelCase__     :			List[Any]     				=						image_processing(image_inputs[0],     return_tensors='pt'					).pixel_values
       self.assertEqual(
           encoded_images.shape,     (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['height'],
               self.image_processor_tester.size['width'],
           ),     )

       # Test batched
       lowerCamelCase__     :			int     				=						image_processing(lowerCamelCase_,     return_tensors='pt'					).pixel_values
       self.assertEqual(
           encoded_images.shape,     (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.size['height'],
               self.image_processor_tester.size['width'],
           ),     )


from sklearn.metrics import mean_absolute_error

import datasets


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


_lowerCamelCase    :      List[str]	 =						'''
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 		__snake_case(  self      :    int					)    -> str:



												'''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 		__snake_case(  self      :    int					)    -> Tuple:



												'''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 		__snake_case(  self      :    Tuple		,							_UpperCamelCase      :    List[str]		,							_UpperCamelCase      :    List[Any]		,							_UpperCamelCase      :    str=None		,							_UpperCamelCase      :    Any="uniform_average"					)    -> int:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE				=				mean_absolute_error(_UpperCamelCase		,							_UpperCamelCase		,							sample_weight=_UpperCamelCase		,							multioutput=_UpperCamelCase					)

												return {"mae": mae_score}




