




'''simple docstring'''






from scipy.stats import spearmanr

import datasets


A_			      =		"\nThe Spearman rank-order correlation coefficient is a measure of the\nrelationship between two datasets. Like other correlation coefficients,\nthis one varies between -1 and +1 with 0 implying no correlation.\nPositive correlations imply that as data in dataset x increases, so\ndoes data in dataset y. Negative correlations imply that as x increases,\ny decreases. Correlations of -1 or +1 imply an exact monotonic relationship.\n\nUnlike the Pearson correlation, the Spearman correlation does not\nassume that both datasets are normally distributed.\n\nThe p-value roughly indicates the probability of an uncorrelated system\nproducing datasets that have a Spearman correlation at least as extreme\nas the one computed from these datasets. The p-values are not entirely\nreliable but are probably reasonable for datasets larger than 500 or so.\n"

A_			      =		"\nArgs:\n    predictions (`List[float]`): Predicted labels, as returned by a model.\n    references (`List[float]`): Ground truth labels.\n    return_pvalue (`bool`): If `True`, returns the p-value. If `False`, returns\n            only the spearmanr score. Defaults to `False`.\nReturns:\n    spearmanr (`float`): Spearman correlation coefficient.\n    p-value (`float`): p-value. **Note**: is only returned if `return_pvalue=True` is input.\nExamples:\n    Example 1:\n        >>> spearmanr_metric = datasets.load_metric(\"spearmanr\")\n        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5], predictions=[10, 9, 2.5, 6, 4])\n        >>> print(results)\n        {'spearmanr': -0.7}\n\n    Example 2:\n        >>> spearmanr_metric = datasets.load_metric(\"spearmanr\")\n        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5],\n        ...                                     predictions=[10, 9, 2.5, 6, 4],\n        ...                                     return_pvalue=True)\n        >>> print(results['spearmanr'])\n        -0.7\n        >>> print(round(results['spearmanr_pvalue'], 2))\n        0.19\n"

A_			      =		R"\\n@book{kokoska2000crc,\n  title={CRC standard probability and statistics tables and formulae},\n  author={Kokoska, Stephen and Zwillinger, Daniel},\n  year={2000},\n  publisher={Crc Press}\n}\n@article{2020SciPy-NMeth,\n  author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n            Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n            Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n            Bright, Jonathan and {van der Walt}, St{\'e}fan J. and\n            Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n            Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n            Kern, Robert and Larson, Eric and Carey, C J and\n            Polat, {\.I}lhan and Feng, Yu and Moore, Eric W. and\n            {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n            Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n            Harris, Charles R. and Archibald, Anne M. and\n            Ribeiro, Ant{\^o}nio H. and Pedregosa, Fabian and\n            {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\n  title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n            Computing in Python}},\n  journal = {Nature Methods},\n  year    = {2020},\n  volume  = {17},\n  pages   = {261--272},\n  adsurl  = {https://rdcu.be/b08Wh},\n  doi     = {10.1038/s41592-019-0686-2},\n}\n"






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





     def 			_lowerCAmelCase      (     self     :					Union[str, Any]			):
           return datasets.MetricInfo(
               description=_DESCRIPTION     ,							citation=_CITATION     ,							inputs_description=_KWARGS_DESCRIPTION     ,							features=datasets.Features(
                   {
                       'predictions': datasets.Value('float'			),
                       'references': datasets.Value('float'			),
                   }			)     ,							reference_urls=['https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html']     ,							)





     def 			_lowerCAmelCase      (     self     :					Tuple     ,							__lowerCamelCase     :					int     ,							__lowerCamelCase     :					Optional[int]     ,							__lowerCamelCase     :					Optional[int]=False			):
           snake_case__       :   Optional[Any]	      =    spearmanr(__lowerCamelCase     ,							__lowerCamelCase			)
           if return_pvalue:
                 return {"spearmanr": results[0], "spearmanr_pvalue": results[1]}
           else:
                 return {"spearmanr": results[0]}






'''simple docstring'''






from typing import Dict, List, Optional, Union

import numpy as np

from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy


A_			      =		logging.get_logger(__name__)






class        lowercase_      (						lowerCAmelCase_							):





     def __init__(     self     :					Union[str, Any]     ,							__lowerCamelCase     :					int     ,							__lowerCamelCase     :					int     ,							__lowerCamelCase     :					float     ,							**__lowerCamelCase     :					Optional[int]			):
           snake_case__       :   int	      =    feature_size
           snake_case__       :   List[str]	      =    sampling_rate
           snake_case__       :   Any	      =    padding_value

           snake_case__       :   Union[str, Any]	      =    kwargs.pop('padding_side'     ,							'right'			)
           snake_case__       :   List[Any]	      =    kwargs.pop('return_attention_mask'     ,							__lowerCamelCase			)

           super().__init__(**__lowerCamelCase			)





     def 			_lowerCAmelCase      (     self     :					Dict     ,							__lowerCamelCase     :					Union[
             BatchFeature,
             List[BatchFeature],
             Dict[str, BatchFeature],
             Dict[str, List[BatchFeature]],
             List[Dict[str, BatchFeature]],
         ]     ,							__lowerCamelCase     :					Union[bool, str, PaddingStrategy] = True     ,							__lowerCamelCase     :					Optional[int] = None     ,							__lowerCamelCase     :					bool = False     ,							__lowerCamelCase     :					Optional[int] = None     ,							__lowerCamelCase     :					Optional[bool] = None     ,							__lowerCamelCase     :					Optional[Union[str, TensorType]] = None     ,							):
           # If we have a list of dicts, let's convert it in a dict of lists
           # We do this to allow using this method as a collate_fn function in PyTorch Dataloader
           if isinstance(__lowerCamelCase     ,							(list, tuple)			) and isinstance(processed_features[0]     ,							(dict, BatchFeature)			):
                 snake_case__       :   int	      =    {
                     key: [example[key] for example in processed_features] for key in processed_features[0].keys()
                 }

           # The model's main input name, usually `input_values`, has be passed for padding
           if self.model_input_names[0] not in processed_features:
                 raise ValueError(
                     'You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`'
                     F" to this method that includes {self.model_input_names[0]}, but you provided"
                     F" {list(processed_features.keys()			)}"			)

           snake_case__       :   Tuple	      =    processed_features[self.model_input_names[0]]
           snake_case__       :   Union[str, Any]	      =    (
               return_attention_mask if return_attention_mask is not None else self.return_attention_mask
           )

           if len(__lowerCamelCase			) == 0:
                 if return_attention_mask:
                       snake_case__       :   str	      =    []
                 return processed_features

           # If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays
           # and rebuild them afterwards if no return_tensors is specified
           # Note that we lose the specific device the tensor may be on for PyTorch

           snake_case__       :   Dict	      =    required_input[0]
           if isinstance(__lowerCamelCase     ,							(list, tuple)			):
                 # first_element might be an empty list/tuple in some edge cases so we grab the first non empty element.
                 snake_case__       :   List[Any]	      =    0
                 while len(required_input[index]			) == 0:
                       index += 1
                 if index < len(__lowerCamelCase			):
                       snake_case__       :   List[Any]	      =    required_input[index][0]

           if return_tensors is None:
                 if is_tf_tensor(__lowerCamelCase			):
                       snake_case__       :   int	      =    'tf'
                 elif is_torch_tensor(__lowerCamelCase			):
                       snake_case__       :   str	      =    'pt'
                 elif isinstance(__lowerCamelCase     ,							(int, float, list, tuple, np.ndarray)			):
                       snake_case__       :   Any	      =    'np'
                 else:
                       raise ValueError(
                           F"type of {first_element} unknown: {type(__lowerCamelCase			)}. "
                           'Should be one of a python, numpy, pytorch or tensorflow object.'			)

           for key, value in processed_features.items():
                 if isinstance(value[0]     ,							(int, float)			):
                       snake_case__       :   List[Any]	      =    to_numpy(__lowerCamelCase			)
                 else:
                       snake_case__       :   List[str]	      =    [to_numpy(__lowerCamelCase			) for v in value]

        # Convert padding_strategy in PaddingStrategy
           snake_case__       :   str	      =    self._get_padding_strategies(padding=__lowerCamelCase     ,							max_length=__lowerCamelCase			)

           snake_case__       :   List[Any]	      =    processed_features[self.model_input_names[0]]

           snake_case__       :   Tuple	      =    len(__lowerCamelCase			)
           if not all(len(__lowerCamelCase			) == batch_size for v in processed_features.values()			):
                 raise ValueError('Some items in the output dictionary have a different batch size than others.'			)

           snake_case__       :   str	      =    []
           for i in range(__lowerCamelCase			):
                 snake_case__       :   str	      =    {k: v[i] for k, v in processed_features.items()}
                 # truncation
                 snake_case__       :   Optional[Any]	      =    self._truncate(
                     __lowerCamelCase     ,							max_length=__lowerCamelCase     ,							pad_to_multiple_of=__lowerCamelCase     ,							truncation=__lowerCamelCase     ,							)
                 truncated_inputs.append(__lowerCamelCase			)

           if padding_strategy == PaddingStrategy.LONGEST:
                 # make sure that `max_length` cannot be longer than the longest truncated length
                 snake_case__       :   Any	      =    max(len(input_slice[self.model_input_names[0]]			) for input_slice in truncated_inputs			)
                 snake_case__       :   Union[str, Any]	      =    PaddingStrategy.MAX_LENGTH

           snake_case__       :   List[Any]	      =    {}
           for i in range(__lowerCamelCase			):
                 # padding
                 snake_case__       :   Tuple	      =    self._pad(
                     truncated_inputs[i]     ,							max_length=__lowerCamelCase     ,							padding_strategy=__lowerCamelCase     ,							pad_to_multiple_of=__lowerCamelCase     ,							return_attention_mask=__lowerCamelCase     ,							)

                 for key, value in outputs.items():
                       if key not in batch_outputs:
                             snake_case__       :   Union[str, Any]	      =    []
                       if value.dtype is np.dtype(np.floataa			):
                             snake_case__       :   int	      =    value.astype(np.floataa			)
                       batch_outputs[key].append(__lowerCamelCase			)

           return BatchFeature(__lowerCamelCase     ,							tensor_type=__lowerCamelCase			)





     def 			_lowerCAmelCase      (     self     :					Optional[int]     ,							__lowerCamelCase     :					Union[Dict[str, np.ndarray], BatchFeature]     ,							__lowerCamelCase     :					Optional[int] = None     ,							__lowerCamelCase     :					PaddingStrategy = PaddingStrategy.DO_NOT_PAD     ,							__lowerCamelCase     :					Optional[int] = None     ,							__lowerCamelCase     :					Optional[bool] = None     ,							):
           snake_case__       :   Optional[int]	      =    processed_features[self.model_input_names[0]]

           if padding_strategy == PaddingStrategy.LONGEST:
                 snake_case__       :   Tuple	      =    len(__lowerCamelCase			)

           if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
                 snake_case__       :   Dict	      =    ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

           snake_case__       :   List[str]	      =    padding_strategy != PaddingStrategy.DO_NOT_PAD and len(__lowerCamelCase			) < max_length

           if return_attention_mask and "attention_mask" not in processed_features:
                 snake_case__       :   Optional[int]	      =    np.ones(len(__lowerCamelCase			)     ,							dtype=np.intaa			)

           if needs_to_be_padded:
                 snake_case__       :   List[Any]	      =    max_length - len(__lowerCamelCase			)
                 if self.padding_side == "right":
                       if return_attention_mask:
                             snake_case__       :   List[str]	      =    np.pad(
                                 processed_features['attention_mask']     ,							(0, difference)			)
                       snake_case__       :   List[Any]	      =    ((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference)
                       snake_case__       :   int	      =    np.pad(
                           __lowerCamelCase     ,							__lowerCamelCase     ,							'constant'     ,							constant_values=self.padding_value			)
                 elif self.padding_side == "left":
                       if return_attention_mask:
                             snake_case__       :   str	      =    np.pad(
                                 processed_features['attention_mask']     ,							(difference, 0)			)
                       snake_case__       :   int	      =    ((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0)
                       snake_case__       :   int	      =    np.pad(
                           __lowerCamelCase     ,							__lowerCamelCase     ,							'constant'     ,							constant_values=self.padding_value			)
                 else:
                       raise ValueError('Invalid padding strategy:' + str(self.padding_side			)			)

           return processed_features





     def 			_lowerCAmelCase      (     self     :					int     ,							__lowerCamelCase     :					Union[Dict[str, np.ndarray], BatchFeature]     ,							__lowerCamelCase     :					Optional[int] = None     ,							__lowerCamelCase     :					Optional[int] = None     ,							__lowerCamelCase     :					Optional[bool] = None     ,							):
           if not truncation:
                 return processed_features
           elif truncation and max_length is None:
                 raise ValueError('When setting ``truncation=True``, make sure that ``max_length`` is defined.'			)

           snake_case__       :   Optional[int]	      =    processed_features[self.model_input_names[0]]

           # find `max_length` that fits `pad_to_multiple_of`
           if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
                 snake_case__       :   List[str]	      =    ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

           snake_case__       :   str	      =    len(__lowerCamelCase			) > max_length

           if needs_to_be_truncated:
                 snake_case__       :   Optional[int]	      =    processed_features[self.model_input_names[0]][:max_length]
                 if "attention_mask" in processed_features:
                       snake_case__       :   List[Any]	      =    processed_features['attention_mask'][:max_length]

           return processed_features





     def 			_lowerCAmelCase      (     self     :					Dict     ,							__lowerCamelCase     :					Optional[int]=False     ,							__lowerCamelCase     :					Optional[Any]=None			):

           # Get padding strategy
           if padding is not False:
                 if padding is True:
                       snake_case__       :   int	      =    PaddingStrategy.LONGEST  # Default to pad to the longest sequence in the batch
                 elif not isinstance(__lowerCamelCase     ,							__lowerCamelCase			):
                       snake_case__       :   str	      =    PaddingStrategy(__lowerCamelCase			)
                 elif isinstance(__lowerCamelCase     ,							__lowerCamelCase			):
                       snake_case__       :   str	      =    padding
           else:
                 snake_case__       :   Union[str, Any]	      =    PaddingStrategy.DO_NOT_PAD

           # Set max length if needed
           if max_length is None:
                 if padding_strategy == PaddingStrategy.MAX_LENGTH:
                       raise ValueError(
                           F"When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined"			)

        # Test if we have a padding value
           if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None):
                 raise ValueError(
                     'Asking to pad but the feature_extractor does not have a padding value. Please select a value to use'
                     ' as `padding_value`. For example: `feature_extractor.padding_value = 0.0`.'			)

           return padding_strategy
