




from scipy.stats import spearmanr

import datasets


UpperCamelCase__					    =    """
The Spearman rank-order correlation coefficient is a measure of the
relationship between two datasets. Like other correlation coefficients,
this one varies between -1 and +1 with 0 implying no correlation.
Positive correlations imply that as data in dataset x increases, so
does data in dataset y. Negative correlations imply that as x increases,
y decreases. Correlations of -1 or +1 imply an exact monotonic relationship.

Unlike the Pearson correlation, the Spearman correlation does not
assume that both datasets are normally distributed.

The p-value roughly indicates the probability of an uncorrelated system
producing datasets that have a Spearman correlation at least as extreme
as the one computed from these datasets. The p-values are not entirely
reliable but are probably reasonable for datasets larger than 500 or so.
"""

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

    Example 2:
        >>> spearmanr_metric = datasets.load_metric(\"spearmanr\")
        >>> results = spearmanr_metric.compute(references=[1, 2, 3, 4, 5],
        ...                                     predictions=[10, 9, 2.5, 6, 4],
        ...                                     return_pvalue=True)
        >>> print(results['spearmanr'])
        -0.7
        >>> print(round(results['spearmanr_pvalue'], 2))
        0.19
"""

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






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											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        __SCREAMING_SNAKE_CASE(     self	,    _A	,    _A	,    _A=False    ):




											"""simple docstring"""



											__lowerCAmelCase            = spearmanr(_A	,    _A    )
											if return_pvalue:
																return {"spearmanr": results[0], "spearmanr_pvalue": results[1]}
											else:
																return {"spearmanr": results[0]}










import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
					from transformers import SpeechaTextFeatureExtractor

UpperCamelCase__					    =    random.Random()







def 			_a   (		SCREAMING_SNAKE_CASE_							:       Union[str, Any]   ,   SCREAMING_SNAKE_CASE_							:       Union[str, Any]=1.0   ,   SCREAMING_SNAKE_CASE_							:       Any=None   ,   SCREAMING_SNAKE_CASE_							:       Any=None  ):
					if rng is None:
										__lowerCAmelCase            = global_rng

					__lowerCAmelCase            = []
					for batch_idx in range(shape[0]  ):
										values.append([]  )
										for _ in range(shape[1]  ):
															values[-1].append(rng.random() * scale  )

					return values
@require_torch
@require_torchaudio
class     a__					(      unittest.TestCase   ):






						def __init__(     self	,    _A	,    _A=7	,    _A=4_0_0	,    _A=2_0_0_0	,    _A=2_4	,    _A=2_4	,    _A=0.0	,    _A=1_6_0_0_0	,    _A=True	,    _A=True	,    ):




											"""simple docstring"""



											__lowerCAmelCase            = parent
											__lowerCAmelCase            = batch_size
											__lowerCAmelCase            = min_seq_length
											__lowerCAmelCase            = max_seq_length
											__lowerCAmelCase            = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
											__lowerCAmelCase            = feature_size
											__lowerCAmelCase            = num_mel_bins
											__lowerCAmelCase            = padding_value
											__lowerCAmelCase            = sampling_rate
											__lowerCAmelCase            = return_attention_mask
											__lowerCAmelCase            = do_normalize






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											return {
											    "feature_size": self.feature_size,
											    "num_mel_bins": self.num_mel_bins,
											    "padding_value": self.padding_value,
											    "sampling_rate": self.sampling_rate,
											    "return_attention_mask": self.return_attention_mask,
											    "do_normalize": self.do_normalize,
											}






						def        __SCREAMING_SNAKE_CASE(     self	,    _A=False	,    _A=False    ):




											"""simple docstring"""



											def _flatten(_A    ):
																return list(itertools.chain(*_A    )    )

											if equal_length:
																__lowerCAmelCase            = [floats_list((self.max_seq_length, self.feature_size)    ) for _ in range(self.batch_size    )]
											else:
																# make sure that inputs increase in size
																__lowerCAmelCase            = [
																    floats_list((x, self.feature_size)    )
																    for x in range(self.min_seq_length	,    self.max_seq_length	,    self.seq_length_diff    )
																]
											if numpify:
																__lowerCAmelCase            = [np.asarray(_A    ) for x in speech_inputs]
											return speech_inputs






@require_torch
@require_torchaudio
class     a__					(      snake_case__				,       unittest.TestCase   ):
						_a							:					Optional[int]      =					SpeechaTextFeatureExtractor if is_speech_available() else None






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = SpeechaTextFeatureExtractionTester(self    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											self.assertTrue(np.all(np.mean(_A	,    axis=0    ) < 1E-3    )    )
											self.assertTrue(np.all(np.abs(np.var(_A	,    axis=0    ) - 1    ) < 1E-3    )    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											# create three inputs of length 800, 1000, and 1200
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]
											__lowerCAmelCase            = [np.asarray(_A    ) for speech_input in speech_inputs]

											# Test feature size
											__lowerCAmelCase            = feature_extractor(_A	,    padding=_A	,    return_tensors="np"    ).input_features
											self.assertTrue(input_features.ndim == 3    )
											self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size    )

											# Test not batched input
											__lowerCAmelCase            = feature_extractor(speech_inputs[0]	,    return_tensors="np"    ).input_features
											__lowerCAmelCase            = feature_extractor(np_speech_inputs[0]	,    return_tensors="np"    ).input_features
											self.assertTrue(np.allclose(_A	,    _A	,    atol=1E-3    )    )

											# Test batched
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="np"    ).input_features
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="np"    ).input_features
											for enc_seq_a, enc_seq_a in zip(_A	,    _A    ):
																self.assertTrue(np.allclose(_A	,    _A	,    atol=1E-3    )    )

											# Test 2-D numpy arrays are batched.
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in (8_0_0, 8_0_0, 8_0_0)]
											__lowerCAmelCase            = np.asarray(_A    )
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="np"    ).input_features
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="np"    ).input_features
											for enc_seq_a, enc_seq_a in zip(_A	,    _A    ):
																self.assertTrue(np.allclose(_A	,    _A	,    atol=1E-3    )    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]

											__lowerCAmelCase            = ["longest", "max_length", "do_not_pad"]
											__lowerCAmelCase            = [None, 1_6, None]
											for max_length, padding in zip(_A	,    _A    ):
																__lowerCAmelCase            = feature_extractor(
																    _A	,    padding=_A	,    max_length=_A	,    return_attention_mask=_A    )
																__lowerCAmelCase            = inputs.input_features
																__lowerCAmelCase            = inputs.attention_mask
																__lowerCAmelCase            = [np.sum(_A    ) for x in attention_mask]

																self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]    )
																self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]    )
																self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]

											__lowerCAmelCase            = ["longest", "max_length", "do_not_pad"]
											__lowerCAmelCase            = [None, 1_6, None]
											for max_length, padding in zip(_A	,    _A    ):
																__lowerCAmelCase            = feature_extractor(
																    _A	,    max_length=_A	,    padding=_A	,    return_tensors="np"	,    return_attention_mask=_A    )
																__lowerCAmelCase            = inputs.input_features
																__lowerCAmelCase            = inputs.attention_mask
																__lowerCAmelCase            = [np.sum(_A    ) for x in attention_mask]

																self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]    )
																self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6    )
																self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]    )
																self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6    )
																self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]
											__lowerCAmelCase            = feature_extractor(
											    _A	,    padding="max_length"	,    max_length=4	,    truncation=_A	,    return_tensors="np"	,    return_attention_mask=_A	,    )
											__lowerCAmelCase            = inputs.input_features
											__lowerCAmelCase            = inputs.attention_mask
											__lowerCAmelCase            = np.sum(attention_mask == 1	,    axis=1    )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
											self._check_zero_mean_unit_variance(input_features[1]    )
											self._check_zero_mean_unit_variance(input_features[2]    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]
											__lowerCAmelCase            = feature_extractor(
											    _A	,    padding="longest"	,    max_length=4	,    truncation=_A	,    return_tensors="np"	,    return_attention_mask=_A	,    )
											__lowerCAmelCase            = inputs.input_features
											__lowerCAmelCase            = inputs.attention_mask
											__lowerCAmelCase            = np.sum(attention_mask == 1	,    axis=1    )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
											self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]    )
											self._check_zero_mean_unit_variance(input_features[2]    )

											# make sure that if max_length < longest -> then pad to max_length
											self.assertEqual(input_features.shape	,    (3, 4, 2_4)    )

											__lowerCAmelCase            = [floats_list((1, x)    )[0] for x in range(8_0_0	,    1_4_0_0	,    2_0_0    )]
											__lowerCAmelCase            = feature_extractor(
											    _A	,    padding="longest"	,    max_length=1_6	,    truncation=_A	,    return_tensors="np"	,    return_attention_mask=_A	,    )
											__lowerCAmelCase            = inputs.input_features
											__lowerCAmelCase            = inputs.attention_mask
											__lowerCAmelCase            = np.sum(attention_mask == 1	,    axis=1    )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
											self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]    )
											self._check_zero_mean_unit_variance(input_features[2]    )

											# make sure that if max_length < longest -> then pad to max_length
											self.assertEqual(input_features.shape	,    (3, 6, 2_4)    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											import torch

											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = np.random.rand(1_0_0	,    3_2    ).astype(np.floataa    )
											__lowerCAmelCase            = np_speech_inputs.tolist()

											for inputs in [py_speech_inputs, np_speech_inputs]:
																__lowerCAmelCase            = feature_extractor.pad([{"input_features": inputs}]	,    return_tensors="np"    )
																self.assertTrue(np_processed.input_features.dtype == np.floataa    )
																__lowerCAmelCase            = feature_extractor.pad([{"input_features": inputs}]	,    return_tensors="pt"    )
																self.assertTrue(pt_processed.input_features.dtype == torch.floataa    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											from datasets import load_dataset

											__lowerCAmelCase            = load_dataset("hf-internal-testing/librispeech_asr_dummy"	,    "clean"	,    split="validation"    )
											# automatic decoding with librispeech
											__lowerCAmelCase            = ds.sort("id"    ).select(range(_A    )    )[:num_samples]["audio"]

											return [x["array"] for x in speech_samples]






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = np.array([
											    -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
											    -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
											    -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
											]    )
											# fmt: on

											__lowerCAmelCase            = self._load_datasamples(1    )
											__lowerCAmelCase            = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
											__lowerCAmelCase            = feature_extractor(_A	,    return_tensors="pt"    ).input_features
											self.assertEquals(input_features.shape	,    (1, 5_8_4, 2_4)    )
											self.assertTrue(np.allclose(input_features[0, 0, :3_0]	,    _A	,    atol=1E-4    )    )




