


import numpy as np

import datasets


_snake_case     :		List[str]						=				'\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'

_snake_case     :		Any						=				'\\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'

_snake_case     :		str						=				'\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 				a		(datasets.Metric      ):




							"""simple docstring"""


							def     __snake_case					(							self       :  Optional[int]				)	->    List[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     __snake_case					(							self       :  List[str]    ,	lowerCamelCase       :  str    ,	lowerCamelCase       :  Tuple				)	->    Union[str, Any]:
														# convert to numpy arrays
														__snake_case		:			int							 =   np.array(lowerCamelCase				)
														__snake_case		:			int							 =   np.array(lowerCamelCase				)

														# 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
														__snake_case		:			int							 =   X - np.mean(lowerCamelCase				)
														__snake_case		:			Optional[int]							 =   np.cov(reference_distribution.T				)
														try:
																					__snake_case		:			List[str]							 =   np.linalg.inv(lowerCamelCase				)
														except np.linalg.LinAlgError:
																					__snake_case		:			Optional[Any]							 =   np.linalg.pinv(lowerCamelCase				)
														__snake_case		:			Any							 =   np.dot(lowerCamelCase    ,	lowerCamelCase				)
														__snake_case		:			Optional[Any]							 =   np.dot(lowerCamelCase    ,	X_minus_mu.T				).diagonal()

														return {"mahalanobis": mahal_dist}



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase  :					List[str]													=       {'configuration_vit_msn': ['VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTMSNConfig']}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase  :					Optional[Any]													=       [
		    'VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'ViTMSNModel',
		    'ViTMSNForImageClassification',
		    'ViTMSNPreTrainedModel',
		]

if TYPE_CHECKING:
		from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_vit_msn import (
				    VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST,
				    ViTMSNForImageClassification,
				    ViTMSNModel,
				    ViTMSNPreTrainedModel,
				)

else:
		import sys

		lowercase  :					Optional[Any]													=       _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)