




'''simple docstring'''


from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
  import PIL


UpperCAmelCase_ 		=      logging.get_logger(__name__)





class    __lowercase						(  __magic_name__ ):
   _a							=      ["""pixel_values"""]







   def __init__(	self      ,							UpperCamelCase = True      ,							UpperCamelCase = None      ,							UpperCamelCase = 0.9      ,							UpperCamelCase = PILImageResampling.BICUBIC      ,							UpperCamelCase = True      ,							UpperCamelCase = None      ,							UpperCamelCase = 1 / 255      ,							UpperCamelCase = True      ,							UpperCamelCase = True      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							**UpperCamelCase      ,							)				->    None:
     super().__init__(**UpperCamelCase      )
     __a			=					size if size is not None else {'shortest_edge': 224}
     __a			=					get_size_dict(UpperCamelCase      ,							default_to_square=UpperCamelCase      )
     __a			=					crop_size if crop_size is not None else {'height': 224, 'width': 224}
     __a			=					get_size_dict(UpperCamelCase      ,							param_name='crop_size'      )

     __a			=					do_resize
     __a			=					size
     __a			=					crop_pct
     __a			=					resample
     __a			=					do_center_crop
     __a			=					crop_size
     __a			=					do_rescale
     __a			=					rescale_factor
     __a			=					do_normalize
     __a			=					image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
     __a			=					image_std if image_std is not None else IMAGENET_DEFAULT_STD







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      ,							UpperCamelCase      ,							UpperCamelCase = None      ,							UpperCamelCase = PILImageResampling.BICUBIC      ,							UpperCamelCase = None      ,							**UpperCamelCase      ,							)				->    np.ndarray:
     __a			=					get_size_dict(UpperCamelCase      ,							default_to_square=UpperCamelCase      )
     if "shortest_edge" not in size and ("height" not in size or "width" not in size):
       raise ValueError(f"size must contain 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"      )
     if crop_pct is not None:
       if "shortest_edge" in size:
         __a			=					int(size['shortest_edge'] / crop_pct      )
       elif "height" in size and "width" in size:
         if size["height"] == size["width"]:
           __a			=					int(size['height'] / crop_pct      )
         else:
           __a			=					(int(size['height'] / crop_pct      ), int(size['width'] / crop_pct      ))
       else:
         raise ValueError('Invalid size for resize: {}'.format(UpperCamelCase      )      )

       __a			=					get_resize_output_image_size(UpperCamelCase      ,							size=UpperCamelCase      ,							default_to_square=UpperCamelCase      )
     else:
       if "shortest_edge" in size:
         __a			=					get_resize_output_image_size(UpperCamelCase      ,							size=size['shortest_edge']      ,							default_to_square=UpperCamelCase      )
       elif "height" in size and "width" in size:
         __a			=					(size['height'], size['width'])
       else:
         raise ValueError('Invalid size for resize: {}'.format(UpperCamelCase      )      )

     return resize(UpperCamelCase      ,							size=UpperCamelCase      ,							resample=UpperCamelCase      ,							data_format=UpperCamelCase      ,							**UpperCamelCase      )







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      ,							UpperCamelCase      ,							UpperCamelCase = None      ,							**UpperCamelCase      ,							)				->    np.ndarray:
     __a			=					get_size_dict(UpperCamelCase      )
     if "height" not in size or "width" not in size:
       raise ValueError(f"size must contain 'height' and 'width' as keys. Got {size.keys()}"      )
     return center_crop(UpperCamelCase      ,							size=(size['height'], size['width'])      ,							data_format=UpperCamelCase      ,							**UpperCamelCase      )







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      ,							UpperCamelCase      ,							UpperCamelCase = None      ,							**UpperCamelCase      ,							)				->    int:
     return rescale(UpperCamelCase      ,							scale=UpperCamelCase      ,							data_format=UpperCamelCase      ,							**UpperCamelCase      )







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      ,							UpperCamelCase      ,							UpperCamelCase      ,							UpperCamelCase = None      ,							**UpperCamelCase      ,							)				->    np.ndarray:
     return normalize(UpperCamelCase      ,							mean=UpperCamelCase      ,							std=UpperCamelCase      ,							data_format=UpperCamelCase      ,							**UpperCamelCase      )







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = None      ,							UpperCamelCase = ChannelDimension.FIRST      ,							**UpperCamelCase      ,							)				->    PIL.Image.Image:
     __a			=					do_resize if do_resize is not None else self.do_resize
     __a			=					crop_pct if crop_pct is not None else self.crop_pct
     __a			=					resample if resample is not None else self.resample
     __a			=					do_center_crop if do_center_crop is not None else self.do_center_crop
     __a			=					do_rescale if do_rescale is not None else self.do_rescale
     __a			=					rescale_factor if rescale_factor is not None else self.rescale_factor
     __a			=					do_normalize if do_normalize is not None else self.do_normalize
     __a			=					image_mean if image_mean is not None else self.image_mean
     __a			=					image_std if image_std is not None else self.image_std

     __a			=					size if size is not None else self.size
     __a			=					get_size_dict(UpperCamelCase      ,							default_to_square=UpperCamelCase      )
     __a			=					crop_size if crop_size is not None else self.crop_size
     __a			=					get_size_dict(UpperCamelCase      ,							param_name='crop_size'      )

     __a			=					make_list_of_images(UpperCamelCase      )

     if not valid_images(UpperCamelCase      ):
       raise ValueError(
           'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
           'torch.Tensor, tf.Tensor or jax.ndarray.'      )

     if do_resize and size is None or resample is None:
       raise ValueError('Size and resample must be specified if do_resize is True.'      )

     if do_center_crop and crop_pct is None:
       raise ValueError('Crop_pct must be specified if do_center_crop is True.'      )

     if do_rescale and rescale_factor is None:
       raise ValueError('Rescale factor must be specified if do_rescale is True.'      )

     if do_normalize and (image_mean is None or image_std is None):
       raise ValueError('Image mean and std must be specified if do_normalize is True.'      )

     # All transformations expect numpy arrays.
     __a			=					[to_numpy_array(UpperCamelCase      ) for image in images]

     if do_resize:
       __a			=					[self.resize(image=UpperCamelCase      ,							size=UpperCamelCase      ,							crop_pct=UpperCamelCase      ,							resample=UpperCamelCase      ) for image in images]

     if do_center_crop:
       __a			=					[self.center_crop(image=UpperCamelCase      ,							size=UpperCamelCase      ) for image in images]

     if do_rescale:
       __a			=					[self.rescale(image=UpperCamelCase      ,							scale=UpperCamelCase      ) for image in images]

     if do_normalize:
       __a			=					[self.normalize(image=UpperCamelCase      ,							mean=UpperCamelCase      ,							std=UpperCamelCase      ) for image in images]

     __a			=					[to_channel_dimension_format(UpperCamelCase      ,							UpperCamelCase      ) for image in images]

     __a			=					{'pixel_values': images}
     return BatchFeature(data=UpperCamelCase      ,							tensor_type=UpperCamelCase      )









'''simple docstring'''


import numpy as np

import datasets


UpperCAmelCase_ 		=      "\nCompute the Mahalanobis Distance\n\nMahalonobis distance is the distance between a point and a distribution.\nAnd not between two distinct points. It is effectively a multivariate equivalent of the Euclidean distance.\nIt was introduced by Prof. P. C. Mahalanobis in 1936\nand has been used in various statistical applications ever since\n[source: https://www.machinelearningplus.com/statistics/mahalanobis-distance/]\n"

UpperCAmelCase_ 		=      "\\n@article{de2000mahalanobis,\n  title={The mahalanobis distance},\n  author={De Maesschalck, Roy and Jouan-Rimbaud, Delphine and Massart, D{\'e}sir{\'e} L},\n  journal={Chemometrics and intelligent laboratory systems},\n  volume={50},\n  number={1},\n  pages={1--18},\n  year={2000},\n  publisher={Elsevier}\n}\n"

UpperCAmelCase_ 		=      "\nArgs:\n    X: List of datapoints to be compared with the `reference_distribution`.\n    reference_distribution: List of datapoints from the reference distribution we want to compare to.\nReturns:\n    mahalanobis: The Mahalonobis distance for each datapoint in `X`.\nExamples:\n\n    >>> mahalanobis_metric = datasets.load_metric(\"mahalanobis\")\n    >>> results = mahalanobis_metric.compute(reference_distribution=[[0, 1], [1, 0]], X=[[0, 1]])\n    >>> print(results)\n    {'mahalanobis': array([0.5])}\n"





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







   def 		UpperCamelCase__			(	self      )				->    Optional[Any]:
     return datasets.MetricInfo(
         description=_DESCRIPTION      ,							citation=_CITATION      ,							inputs_description=_KWARGS_DESCRIPTION      ,							features=datasets.Features(
             {
                 'X': datasets.Sequence(datasets.Value('float'      ,							id='sequence'      )      ,							id='X'      ),
             }      )      ,							)







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      ,							UpperCamelCase      )				->    Optional[int]:
     # convert to numpy arrays
     __a			=					np.array(UpperCamelCase      )
     __a			=					np.array(UpperCamelCase      )

     # Assert that arrays are 2D
     if len(X.shape      ) != 2:
       raise ValueError('Expected `X` to be a 2D vector'      )
     if len(reference_distribution.shape      ) != 2:
       raise ValueError('Expected `reference_distribution` to be a 2D vector'      )
     if reference_distribution.shape[0] < 2:
       raise ValueError(
           'Expected `reference_distribution` to be a 2D vector with more than one element in the first dimension'      )

     # Get mahalanobis distance for each prediction
     __a			=					X - np.mean(UpperCamelCase      )
     __a			=					np.cov(reference_distribution.T      )
     try:
       __a			=					np.linalg.inv(UpperCamelCase      )
     except np.linalg.LinAlgError:
       __a			=					np.linalg.pinv(UpperCamelCase      )
     __a			=					np.dot(UpperCamelCase      ,							UpperCamelCase      )
     __a			=					np.dot(UpperCamelCase      ,							X_minus_mu.T      ).diagonal()

     return {"mahalanobis": mahal_dist}



