
import numpy as np

import datasets


A     :	str    = '''
Compute the Mahalanobis Distance

Mahalonobis distance is the distance between a point and a distribution.
And not between two distinct points. It is effectively a multivariate equivalent of the Euclidean distance.
It was introduced by Prof. P. C. Mahalanobis in 1936
and has been used in various statistical applications ever since
[source: https://www.machinelearningplus.com/statistics/mahalanobis-distance/]
'''

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

A     :	List[Any]    = '''
Args:
    X: List of datapoints to be compared with the `reference_distribution`.
    reference_distribution: List of datapoints from the reference distribution we want to compare to.
Returns:
    mahalanobis: The Mahalonobis distance for each datapoint in `X`.
Examples:

    >>> mahalanobis_metric = datasets.load_metric("mahalanobis")
    >>> results = mahalanobis_metric.compute(reference_distribution=[[0, 1], [1, 0]], X=[[0, 1]])
    >>> print(results)
    {\'mahalanobis\': array([0.5])}
'''







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




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      List[str]:


								'''simple docstring'''




								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 				SCREAMING_SNAKE_CASE_		(     self		,     _snake_case		,     _snake_case				)    ->      Union[str, Any]:


								'''simple docstring'''




								__a										=    np.array(lowerCAmelCase__				)
								__a										=    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
								__a										=    X - np.mean(lowerCAmelCase__				)
								__a										=    np.cov(reference_distribution.T				)
								try:
												__a										=    np.linalg.inv(lowerCAmelCase__				)
								except np.linalg.LinAlgError:
												__a										=    np.linalg.pinv(lowerCAmelCase__				)
								__a										=    np.dot(lowerCAmelCase__		,     lowerCAmelCase__				)
								__a										=    np.dot(lowerCAmelCase__		,     X_minus_mu.T				).diagonal()

								return {"mahalanobis": mahal_dist}




'''simple docstring'''




# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


UpperCamelCase__       :	List[Any]    = [
    '''EAGER''',
    '''AOT_EAGER''',
    '''INDUCTOR''',
    '''NVFUSER''',
    '''AOT_NVFUSER''',
    '''AOT_CUDAGRAPHS''',
    '''OFI''',
    '''FX2TRT''',
    '''ONNXRT''',
    '''IPEX''',
]


def 				lowerCAmelCase_   (	_lowerCamelCase:   str       ,      _lowerCamelCase:   Union[str, Any]=None       ,      _lowerCamelCase:   Optional[int]=None       ,      _lowerCamelCase:   str=None					):
		__SCREAMING_SNAKE_CASE       :		Optional[int]           =		True
		while ask_again:
				__SCREAMING_SNAKE_CASE       :		Tuple           =		input(_lowerCamelCase					)
				try:
						if default is not None and len(_lowerCamelCase					) == 0:
								return default
						return convert_value(_lowerCamelCase					) if convert_value is not None else result
				except Exception:
						if error_message is not None:
								print(_lowerCamelCase					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Tuple       ,      _lowerCamelCase:   Union[str, Any]=[]       ,      _lowerCamelCase:   List[Any]=None       ,      _lowerCamelCase:   Optional[Any]=0					):
		__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		BulletMenu(_lowerCamelCase       ,      _lowerCamelCase					)
		__SCREAMING_SNAKE_CASE       :		Dict           =		menu.run(default_choice=_lowerCamelCase					)
		return convert_value(_lowerCamelCase					) if convert_value is not None else result


def 				lowerCAmelCase_   (	_lowerCamelCase:   Optional[Any]					):
		__SCREAMING_SNAKE_CASE       :		List[str]           =		int(_lowerCamelCase					)
		return ComputeEnvironment(["""LOCAL_MACHINE""", """AMAZON_SAGEMAKER"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Any					):
		__SCREAMING_SNAKE_CASE       :		str           =		int(_lowerCamelCase					)
		return DistributedType(["""NO""", """MULTI_CPU""", """MULTI_XPU""", """MULTI_GPU""", """MULTI_NPU""", """TPU"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Tuple					):
		__SCREAMING_SNAKE_CASE       :		Tuple           =		int(_lowerCamelCase					)
		return DynamoBackend(DYNAMO_BACKENDS[value]					).value


def 				lowerCAmelCase_   (	_lowerCamelCase:   Union[str, Any]					):
		__SCREAMING_SNAKE_CASE       :		List[str]           =		int(_lowerCamelCase					)
		return PrecisionType(["""no""", """fp16""", """bf16""", """fp8"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   Tuple					):
		__SCREAMING_SNAKE_CASE       :		int           =		int(_lowerCamelCase					)
		return SageMakerDistributedType(["""NO""", """DATA_PARALLEL""", """MODEL_PARALLEL"""][value]					)


def 				lowerCAmelCase_   (	_lowerCamelCase:   List[Any]					):
		return {"yes": True, "no": False}[value.lower()]






class 						_UpperCamelCase  (							argparse.RawDescriptionHelpFormatter    ):


			'''simple docstring'''

			def UpperCamelCase__					(							self     : Tuple							,     lowerCAmelCase__     : Optional[Any]							,     lowerCAmelCase__     : Dict							,     lowerCAmelCase__     : List[Any]							,     lowerCAmelCase__     : List[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		super()._format_usage(lowerCAmelCase__							,     lowerCAmelCase__							,     lowerCAmelCase__							,     lowerCAmelCase__						)
					__SCREAMING_SNAKE_CASE       :		Any           =		usage.replace("""<command> [<args>] """							,     """"""						)
					return usage