code: 
  
  
  '''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 OwlViTImageProcessor
  class _lowerCamelCase (		unittest.TestCase							):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def __init__(      self	:		str						,  _A	:		Any						,  _A	:		str=7						,  _A	:		List[str]=3						,  _A	:		Optional[Any]=18						,  _A	:		str=30						,  _A	:		List[Any]=400						,  _A	:		List[Any]=True						,  _A	:		List[Any]=None						,  _A	:		List[str]=True						,  _A	:		Optional[int]=None						,  _A	:		List[Any]=True						,  _A	:		List[str]=[0.4814_5466, 0.457_8275, 0.4082_1073]						,  _A	:		Optional[Any]=[0.2686_2954, 0.2613_0258, 0.2757_7711]						,  _A	:		str=True						,  )						->				Any:
  			__magic_name__ :					str  			=  parent
  			__magic_name__ :					Dict  			=  batch_size
  			__magic_name__ :					int  			=  num_channels
  			__magic_name__ :					Union[str, Any]  			=  image_size
  			__magic_name__ :					Union[str, Any]  			=  min_resolution
  			__magic_name__ :					int  			=  max_resolution
  			__magic_name__ :					str  			=  do_resize
  			__magic_name__ :					Optional[Any]  			=  size if size is not None else {'height': 18, 'width': 18}
  			__magic_name__ :					Tuple  			=  do_center_crop
  			__magic_name__ :					Dict  			=  crop_size if crop_size is not None else {'height': 18, 'width': 18}
  			__magic_name__ :					Dict  			=  do_normalize
  			__magic_name__ :					List[str]  			=  image_mean
  			__magic_name__ :					Optional[int]  			=  image_std
  			__magic_name__ :					Tuple  			=  do_convert_rgb
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Union[str, Any]    )						->				str:
  			return {
  			    "do_resize": self.do_resize,
  			    "size": self.size,
  			    "do_center_crop": self.do_center_crop,
  			    "crop_size": self.crop_size,
  			    "do_normalize": self.do_normalize,
  			    "image_mean": self.image_mean,
  			    "image_std": self.image_std,
  			    "do_convert_rgb": self.do_convert_rgb,
  			}
  
  
  
  
  
  
  
  @require_torch
  @require_vision
  class _lowerCamelCase (		lowercase__	,  unittest.TestCase							):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		A_			:    Any   					=       OwlViTImageProcessor if is_vision_available() else None
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Tuple    )						->				Union[str, Any]:
  			__magic_name__ :					str  			=  OwlViTImageProcessingTester(self    )
  
  
  
  
  
  
  
  		@property
  		def      __lowerCAmelCase	(      self	:		str    )						->				List[str]:
  			return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		int    )						->				Union[str, Any]:
  			__magic_name__ :					Union[str, Any]  			=  self.image_processing_class(**self.image_processor_dict    )
  			self.assertTrue(hasattr(_A						,  'do_resize'    )    )
  			self.assertTrue(hasattr(_A						,  'size'    )    )
  			self.assertTrue(hasattr(_A						,  'do_center_crop'    )    )
  			self.assertTrue(hasattr(_A						,  'center_crop'    )    )
  			self.assertTrue(hasattr(_A						,  'do_normalize'    )    )
  			self.assertTrue(hasattr(_A						,  'image_mean'    )    )
  			self.assertTrue(hasattr(_A						,  'image_std'    )    )
  			self.assertTrue(hasattr(_A						,  'do_convert_rgb'    )    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		List[str]    )						->				List[Any]:
  			__magic_name__ :					int  			=  self.image_processing_class.from_dict(self.image_processor_dict    )
  			self.assertEqual(image_processor.size						,  {'height': 18, 'width': 18}    )
  			self.assertEqual(image_processor.crop_size						,  {'height': 18, 'width': 18}    )
  
  			__magic_name__ :					List[str]  			=  self.image_processing_class.from_dict(self.image_processor_dict						,  size=42						,  crop_size=84    )
  			self.assertEqual(image_processor.size						,  {'height': 42, 'width': 42}    )
  			self.assertEqual(image_processor.crop_size						,  {'height': 84, 'width': 84}    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Tuple    )						->				Dict:
  			# Initialize image_processing
  			__magic_name__ :					List[str]  			=  self.image_processing_class(**self.image_processor_dict    )
  			# create random PIL images
  			__magic_name__ :					Optional[int]  			=  prepare_image_inputs(self.image_processor_tester						,  equal_resolution=_A    )
  
  			for image in image_inputs:
  				self.assertIsInstance(_A						,  Image.Image    )
  
  			# Test not batched input
  			__magic_name__ :					Optional[int]  			=  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.crop_size['height'],
  			        self.image_processor_tester.crop_size['width'],
  			    )						,  )
  
  			# Test batched
  			__magic_name__ :					str  			=  image_processing(_A						,  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.crop_size['height'],
  			        self.image_processor_tester.crop_size['width'],
  			    )						,  )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Tuple    )						->				Any:
  			# Initialize image_processing
  			__magic_name__ :					Optional[int]  			=  self.image_processing_class(**self.image_processor_dict    )
  			# create random numpy tensors
  			__magic_name__ :					Optional[Any]  			=  prepare_image_inputs(self.image_processor_tester						,  equal_resolution=_A						,  numpify=_A    )
  			for image in image_inputs:
  				self.assertIsInstance(_A						,  np.ndarray    )
  
  			# Test not batched input
  			__magic_name__ :					Optional[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.crop_size['height'],
  			        self.image_processor_tester.crop_size['width'],
  			    )						,  )
  
  			# Test batched
  			__magic_name__ :					Optional[int]  			=  image_processing(_A						,  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.crop_size['height'],
  			        self.image_processor_tester.crop_size['width'],
  			    )						,  )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		List[str]    )						->				Optional[Any]:
  			# Initialize image_processing
  			__magic_name__ :					Tuple  			=  self.image_processing_class(**self.image_processor_dict    )
  			# create random PyTorch tensors
  			__magic_name__ :					Optional[int]  			=  prepare_image_inputs(self.image_processor_tester						,  equal_resolution=_A						,  torchify=_A    )
  			for image in image_inputs:
  				self.assertIsInstance(_A						,  torch.Tensor    )
  
  			# Test not batched input
  			__magic_name__ :					Optional[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.crop_size['height'],
  			        self.image_processor_tester.crop_size['width'],
  			    )						,  )
  
  			# Test batched
  			__magic_name__ :					int  			=  image_processing(_A						,  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.crop_size['height'],
  			        self.image_processor_tester.crop_size['width'],
  			    )						,  )
style_context: 
  
  
  '''simple docstring'''
  
  from sklearn.metrics import mean_absolute_error
  
  import datasets
  
  
  lowerCAmelCase   :Union[str, 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   :int								=    '''\
  Mean Absolute Error (MAE) is the mean of the magnitude of difference between the predicted and actual
  values.
  '''
  
  
  lowerCAmelCase   :Optional[int]								=    '''
  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 _lowerCamelCase (		datasets.Metric							):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Union[str, Any]    )						->				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      __lowerCAmelCase	(      self	:		Tuple    )						->				List[str]:
  			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	:		Dict						,  _A	:		Optional[int]						,  _A	:		Optional[Any]						,  _A	:		Optional[Any]=None						,  _A	:		Tuple="uniform_average"    )						->				Any:
  			__magic_name__ :					Optional[Any]  			=  mean_absolute_error(_A						,  _A						,  sample_weight=_A						,  multioutput=_A    )
  
  			return {"mae": mae_score}