






"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


lowerCamelCase_							      = logging.get_logger(__name__)

lowerCamelCase_							      = {
    '''google/bit-50''': '''https://huggingface.co/google/bit-50/resolve/main/config.json''',
}







class      UpperCamelCase_			(__A							,		__A	):
	__magic_name__       =							'''bit'''
	__magic_name__       =							['''preactivation''', '''bottleneck''']
	__magic_name__       =							['''SAME''', '''VALID''']





	def __init__( self   :					str      ,      lowerCAmelCase_   :					int=3      ,      lowerCAmelCase_   :					Any=64      ,      lowerCAmelCase_   :					Optional[Any]=[256, 512, 1_024, 2_048]      ,      lowerCAmelCase_   :					Tuple=[3, 4, 6, 3]      ,      lowerCAmelCase_   :					Optional[Any]="preactivation"      ,      lowerCAmelCase_   :					Optional[int]="relu"      ,      lowerCAmelCase_   :					Tuple=None      ,      lowerCAmelCase_   :					List[str]=32      ,      lowerCAmelCase_   :					Tuple=0.0      ,      lowerCAmelCase_   :					Dict=False      ,      lowerCAmelCase_   :					Any=32      ,      lowerCAmelCase_   :					List[Any]=1      ,      lowerCAmelCase_   :					Optional[Any]=None      ,      lowerCAmelCase_   :					Optional[int]=None      ,      **lowerCAmelCase_   :					List[Any]      ,      )		->     Optional[Any]:
				super().__init__(**lowerCAmelCase_		)
				if layer_type not in self.layer_types:
							raise ValueError(f"""layer_type={layer_type} is not one of {','.join(self.layer_types		)}"""		)
				if global_padding is not None:
							if global_padding.upper() in self.supported_padding:
										UpperCAmelCase_	:					Optional[int]     	=   global_padding.upper()
							else:
										raise ValueError(f"""Padding strategy {global_padding} not supported"""		)
				UpperCAmelCase_	:					Optional[Any]     	=   num_channels
				UpperCAmelCase_	:					Optional[int]     	=   embedding_size
				UpperCAmelCase_	:					Optional[Any]     	=   hidden_sizes
				UpperCAmelCase_	:					Dict     	=   depths
				UpperCAmelCase_	:					Dict     	=   layer_type
				UpperCAmelCase_	:					Any     	=   hidden_act
				UpperCAmelCase_	:					Optional[Any]     	=   global_padding
				UpperCAmelCase_	:					List[str]     	=   num_groups
				UpperCAmelCase_	:					Any     	=   drop_path_rate
				UpperCAmelCase_	:					Optional[Any]     	=   embedding_dynamic_padding
				UpperCAmelCase_	:					str     	=   output_stride
				UpperCAmelCase_	:					List[str]     	=   width_factor

				UpperCAmelCase_	:					Tuple     	=   ["stem"] + [f"""stage{idx}""" for idx in range(1      ,      len(lowerCAmelCase_		) + 1		)]
				UpperCAmelCase_	,      UpperCAmelCase_	:					Union[str, Any]     	=   get_aligned_output_features_output_indices(
				    out_features=lowerCAmelCase_      ,      out_indices=lowerCAmelCase_      ,      stage_names=self.stage_names		)




import numpy as np

import datasets


SCREAMING_SNAKE_CASE		:     Optional[int]         =	"\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"

SCREAMING_SNAKE_CASE		:     Dict         =	"\\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"

SCREAMING_SNAKE_CASE		:     List[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        UpperCamelCase						(				datasets.Metric				):





						def        A_							(self						)				->				str:
												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        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase						)				->				int:
												# convert to numpy arrays
												UpperCamelCase_		:							int  =		np.array(__UpperCamelCase						)
												UpperCamelCase_		:							Union[str, Any]  =		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
												UpperCamelCase_		:							str  =		X - np.mean(__UpperCamelCase						)
												UpperCamelCase_		:							Dict  =		np.cov(reference_distribution.T						)
												try:
																		UpperCamelCase_		:							str  =		np.linalg.inv(__UpperCamelCase						)
												except np.linalg.LinAlgError:
																		UpperCamelCase_		:							List[Any]  =		np.linalg.pinv(__UpperCamelCase						)
												UpperCamelCase_		:							Tuple  =		np.dot(__UpperCamelCase			,     __UpperCamelCase						)
												UpperCamelCase_		:							Tuple  =		np.dot(__UpperCamelCase			,     X_minus_mu.T						).diagonal()

												return {"mahalanobis": mahal_dist}






