






"""simple docstring"""
import numpy as np

import datasets


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

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

lowerCAmelCase__    						=			'\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 _lowerCAmelCase						(    datasets.Metric       ):







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

										return {"mahalanobis": mahal_dist}









"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase__    						=			logging.get_logger(__name__)

lowerCAmelCase__    						=			{
    'caidas/swin2sr-classicalsr-x2-64': (
        'https://huggingface.co/caidas/swin2sr-classicalsr-x2-64/resolve/main/config.json'
    ),
}


class _lowerCAmelCase						(    __UpperCAmelCase       ):
						SCREAMING_SNAKE_CASE_:					Any 					=				'swin2sr'

						SCREAMING_SNAKE_CASE_:					Dict 					=				{
						    'hidden_size': 'embed_dim',
						    'num_attention_heads': 'num_heads',
						    'num_hidden_layers': 'num_layers',
						}







						def __init__(    self   ,				lowerCAmelCase_=6_4   ,				lowerCAmelCase_=1   ,				lowerCAmelCase_=3   ,				lowerCAmelCase_=1_8_0   ,				lowerCAmelCase_=[6, 6, 6, 6, 6, 6]   ,				lowerCAmelCase_=[6, 6, 6, 6, 6, 6]   ,				lowerCAmelCase_=8   ,				lowerCAmelCase_=2.0   ,				lowerCAmelCase_=True   ,				lowerCAmelCase_=0.0   ,				lowerCAmelCase_=0.0   ,				lowerCAmelCase_=0.1   ,				lowerCAmelCase_="gelu"   ,				lowerCAmelCase_=False   ,				lowerCAmelCase_=0.02   ,				lowerCAmelCase_=1e-5   ,				lowerCAmelCase_=2   ,				lowerCAmelCase_=1.0   ,				lowerCAmelCase_="1conv"   ,				lowerCAmelCase_="pixelshuffle"   ,				**lowerCAmelCase_   ,				)		->							Dict:
										super().__init__(**lowerCAmelCase_							)

										_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    image_size
										_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    patch_size
										_SCREAMING_SNAKE_CASE   :		str       		=    num_channels
										_SCREAMING_SNAKE_CASE   :		Any       		=    embed_dim
										_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    depths
										_SCREAMING_SNAKE_CASE   :		List[Any]       		=    len(lowerCAmelCase_							)
										_SCREAMING_SNAKE_CASE   :		Tuple       		=    num_heads
										_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    window_size
										_SCREAMING_SNAKE_CASE   :		List[str]       		=    mlp_ratio
										_SCREAMING_SNAKE_CASE   :		List[str]       		=    qkv_bias
										_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    hidden_dropout_prob
										_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    attention_probs_dropout_prob
										_SCREAMING_SNAKE_CASE   :		Optional[int]       		=    drop_path_rate
										_SCREAMING_SNAKE_CASE   :		int       		=    hidden_act
										_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    use_absolute_embeddings
										_SCREAMING_SNAKE_CASE   :		str       		=    layer_norm_eps
										_SCREAMING_SNAKE_CASE   :		List[Any]       		=    initializer_range
										_SCREAMING_SNAKE_CASE   :		List[Any]       		=    upscale
										_SCREAMING_SNAKE_CASE   :		str       		=    img_range
										_SCREAMING_SNAKE_CASE   :		Any       		=    resi_connection
										_SCREAMING_SNAKE_CASE   :		Tuple       		=    upsampler

