




"""simple docstring"""




import numpy as np

import datasets


a_        =       '\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'

a_        =       '\\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'

a_        =       '\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   UpperCAmelCase_    (			datasets.Metric		):
		def 	_lowerCamelCase							(						self       )						->       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 	_lowerCamelCase							(						self				,						UpperCamelCase_				,						UpperCamelCase_       )						->       Tuple:
					# convert to numpy arrays
					__lowercase			:  Dict								=       np.array(UpperCamelCase_       )
					__lowercase			:  str								=       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
					__lowercase			:  Tuple								=       X - np.mean(UpperCamelCase_       )
					__lowercase			:  List[Any]								=       np.cov(reference_distribution.T       )
					try:
								__lowercase			:  Tuple								=       np.linalg.inv(UpperCamelCase_       )
					except np.linalg.LinAlgError:
								__lowercase			:  str								=       np.linalg.pinv(UpperCamelCase_       )
					__lowercase			:  Any								=       np.dot(UpperCamelCase_				,						UpperCamelCase_       )
					__lowercase			:  Optional[Any]								=       np.dot(UpperCamelCase_				,						X_minus_mu.T       ).diagonal()

					return {"mahalanobis": mahal_dist}





"""simple docstring"""





import copy
from collections import OrderedDict
from typing import Dict, Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


_a								=						logging.get_logger(__name__)

_a								=						{
    """facebook/detr-resnet-50""": """https://huggingface.co/facebook/detr-resnet-50/resolve/main/config.json""",
    # See all DETR models at https://huggingface.co/models?filter=detr
}






class        _UpperCAmelCase(       lowerCamelCase      ):
		lowercase__         = 'detr'
		lowercase__         = ['past_key_values']
		lowercase__         = {
		    'hidden_size': 'd_model',
		    'num_attention_heads': 'encoder_attention_heads',
		}



		def __init__(   self							,						__a=True							,						__a=None							,						__a=3							,						__a=1_00							,						__a=6							,						__a=20_48							,						__a=8							,						__a=6							,						__a=20_48							,						__a=8							,						__a=0.0							,						__a=0.0							,						__a=True							,						__a="relu"							,						__a=2_56							,						__a=0.1							,						__a=0.0							,						__a=0.0							,						__a=0.02							,						__a=1.0							,						__a=False							,						__a="sine"							,						__a="resnet50"							,						__a=True							,						__a=False							,						__a=1							,						__a=5							,						__a=2							,						__a=1							,						__a=1							,						__a=5							,						__a=2							,						__a=0.1							,						**__a							,						)			->			int:






							'''simple docstring'''
							if backbone_config is not None and use_timm_backbone:
												raise ValueError('''You can\'t specify both `backbone_config` and `use_timm_backbone`.''')

							if not use_timm_backbone:
												if backbone_config is None:
																	logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.''')
																	_UpperCamelCase									=    CONFIG_MAPPING['''resnet'''](out_features=['''stage4'''])
												elif isinstance(__a							,						__a):
																	_UpperCamelCase									=    backbone_config.get('''model_type''')
																	_UpperCamelCase									=    CONFIG_MAPPING[backbone_model_type]
																	_UpperCamelCase									=    config_class.from_dict(__a)
												# set timm attributes to None
												_UpperCamelCase					,    _UpperCamelCase					,    _UpperCamelCase									=    None, None, None

							_UpperCamelCase									=    use_timm_backbone
							_UpperCamelCase									=    backbone_config
							_UpperCamelCase									=    num_channels
							_UpperCamelCase									=    num_queries
							_UpperCamelCase									=    d_model
							_UpperCamelCase									=    encoder_ffn_dim
							_UpperCamelCase									=    encoder_layers
							_UpperCamelCase									=    encoder_attention_heads
							_UpperCamelCase									=    decoder_ffn_dim
							_UpperCamelCase									=    decoder_layers
							_UpperCamelCase									=    decoder_attention_heads
							_UpperCamelCase									=    dropout
							_UpperCamelCase									=    attention_dropout
							_UpperCamelCase									=    activation_dropout
							_UpperCamelCase									=    activation_function
							_UpperCamelCase									=    init_std
							_UpperCamelCase									=    init_xavier_std
							_UpperCamelCase									=    encoder_layerdrop
							_UpperCamelCase									=    decoder_layerdrop
							_UpperCamelCase									=    encoder_layers
							_UpperCamelCase									=    auxiliary_loss
							_UpperCamelCase									=    position_embedding_type
							_UpperCamelCase									=    backbone
							_UpperCamelCase									=    use_pretrained_backbone
							_UpperCamelCase									=    dilation
							# Hungarian matcher
							_UpperCamelCase									=    class_cost
							_UpperCamelCase									=    bbox_cost
							_UpperCamelCase									=    giou_cost
							# Loss coefficients
							_UpperCamelCase									=    mask_loss_coefficient
							_UpperCamelCase									=    dice_loss_coefficient
							_UpperCamelCase									=    bbox_loss_coefficient
							_UpperCamelCase									=    giou_loss_coefficient
							_UpperCamelCase									=    eos_coefficient
							super().__init__(is_encoder_decoder=__a							,						**__a)



		@property
		def 		UpperCAmelCase				(   self)			->			int:






							'''simple docstring'''
							return self.encoder_attention_heads



		@property
		def 		UpperCAmelCase				(   self)			->			int:






							'''simple docstring'''
							return self.d_model



		@classmethod
		def 		UpperCAmelCase				(   cls							,						__a							,						**__a)			->			int:






							'''simple docstring'''
							return cls(backbone_config=__a							,						**__a)




		def 		UpperCAmelCase				(   self)			->			Dict[str, any]:






							'''simple docstring'''
							_UpperCamelCase									=    copy.deepcopy(self.__dict__)
							if output["backbone_config"] is not None:
												_UpperCamelCase									=    self.backbone_config.to_dict()
							_UpperCamelCase									=    self.__class__.model_type
							return output






class        _UpperCAmelCase(       lowerCamelCase      ):
		lowercase__         = version.parse('1.11'      )



		@property
		def 		UpperCAmelCase				(   self)			->			Mapping[str, Mapping[int, str]]:






							'''simple docstring'''
							return OrderedDict(
							    [
							        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
							        ('''pixel_mask''', {0: '''batch'''}),
							    ])



		@property
		def 		UpperCAmelCase				(   self)			->			float:






							'''simple docstring'''
							return 1e-5




		@property
		def 		UpperCAmelCase				(   self)			->			int:






							'''simple docstring'''
							return 12






