
from scipy.stats import spearmanr

import datasets


lowercase						:      Union[str, Any]									= '\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'

lowercase						:      Dict									= '\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'

lowercase						:      Tuple									= 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 				lowerCamelCase__							(       datasets.Metric):




	'''simple docstring'''




	def      _lowerCamelCase       (      self	:Any		)	->				Tuple:
								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	:int  ,     a	:Union[str, Any]  ,     a	:str  ,     a	:Any=False		)	->				Union[str, Any]:
								__UpperCamelCase			:     str         =      spearmanr(a  ,     a		)
								if return_pvalue:
															return {"spearmanr": results[0], "spearmanr_pvalue": results[1]}
								else:
															return {"spearmanr": results[0]}

import collections
import gzip
import os
import urllib

import numpy
from tensorflow.python.framework import dtypes, random_seed
from tensorflow.python.platform import gfile
from tensorflow.python.util.deprecation import deprecated

lowercase						:      List[str]									= collections.namedtuple('_Datasets', ['train', 'validation', 'test'])

# CVDF mirror of http://yann.lecun.com/exdb/mnist/
lowercase						:      List[Any]									= 'https://storage.googleapis.com/cvdf-datasets/mnist/'




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    List[Any])      ->					Optional[int]:






							'''simple docstring'''





							__UpperCamelCase			:     str         =      numpy.dtype(numpy.uintaa).newbyteorder(">")
							return numpy.frombuffer(bytestream.read(4)		,						dtype=_lowerCamelCase)[0]




@deprecated(_lowerCamelCase		,						"Please use tf.data to implement this functionality.")
def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    int)      ->					Any:






							'''simple docstring'''





							print("Extracting"		,						f.name)
							with gzip.GzipFile(fileobj=_lowerCamelCase) as bytestream:
														__UpperCamelCase			:     str         =      _readaa(_lowerCamelCase)
														if magic != 2_051:
																					raise ValueError(
																					    "Invalid magic number %d in MNIST image file: %s" % (magic, f.name))
														__UpperCamelCase			:     List[str]         =      _readaa(_lowerCamelCase)
														__UpperCamelCase			:     Dict         =      _readaa(_lowerCamelCase)
														__UpperCamelCase			:     Optional[int]         =      _readaa(_lowerCamelCase)
														__UpperCamelCase			:     Dict         =      bytestream.read(rows * cols * num_images)
														__UpperCamelCase			:     Optional[int]         =      numpy.frombuffer(_lowerCamelCase		,						dtype=numpy.uinta)
														__UpperCamelCase			:     Dict         =      data.reshape(_lowerCamelCase		,						_lowerCamelCase		,						_lowerCamelCase		,						1)
														return data




@deprecated(_lowerCamelCase		,						"Please use tf.one_hot on tensors.")
def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    List[str]		,						_lowerCamelCase				:    List[str])      ->					str:






							'''simple docstring'''





							__UpperCamelCase			:     str         =      labels_dense.shape[0]
							__UpperCamelCase			:     str         =      numpy.arange(_lowerCamelCase) * num_classes
							__UpperCamelCase			:     str         =      numpy.zeros((num_labels, num_classes))
							__UpperCamelCase			:     Tuple         =      1
							return labels_one_hot




@deprecated(_lowerCamelCase		,						"Please use tf.data to implement this functionality.")
def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Union[str, Any]		,						_lowerCamelCase				:    Optional[int]=False		,						_lowerCamelCase				:    Optional[int]=10)      ->					Dict:






							'''simple docstring'''





							print("Extracting"		,						f.name)
							with gzip.GzipFile(fileobj=_lowerCamelCase) as bytestream:
														__UpperCamelCase			:     int         =      _readaa(_lowerCamelCase)
														if magic != 2_049:
																					raise ValueError(
																					    "Invalid magic number %d in MNIST label file: %s" % (magic, f.name))
														__UpperCamelCase			:     Any         =      _readaa(_lowerCamelCase)
														__UpperCamelCase			:     List[Any]         =      bytestream.read(_lowerCamelCase)
														__UpperCamelCase			:     Dict         =      numpy.frombuffer(_lowerCamelCase		,						dtype=numpy.uinta)
														if one_hot:
																					return _dense_to_one_hot(_lowerCamelCase		,						_lowerCamelCase)
														return labels




class 				lowerCamelCase__							:




	'''simple docstring'''




	@deprecated(
	    a  ,     "Please use alternatives such as official/mnist/_DataSet.py"
	    " from tensorflow/models."  ,     )
	def __init__(      self	:int  ,     a	:Any  ,     a	:List[str]  ,     a	:Union[str, Any]=False  ,     a	:List[Any]=False  ,     a	:Dict=dtypes.floataa  ,     a	:int=True  ,     a	:Optional[int]=None  ,     )	->				List[str]:
								__UpperCamelCase     ,		__UpperCamelCase			:     Optional[int]         =      random_seed.get_seed(a		)
								# If op level seed is not set, use whatever graph level seed is returned
								numpy.random.seed(seeda if seed is None else seeda		)
								__UpperCamelCase			:     Optional[Any]         =      dtypes.as_dtype(a		).base_dtype
								if dtype not in (dtypes.uinta, dtypes.floataa):
															raise TypeError("Invalid image dtype %r, expected uint8 or float32" % dtype		)
								if fake_data:
															__UpperCamelCase			:     str         =      1_0_0_0_0
															__UpperCamelCase			:     Optional[Any]         =      one_hot
								else:
															assert (
															    images.shape[0] == labels.shape[0]
															), f'images.shape: {images.shape} labels.shape: {labels.shape}'
															__UpperCamelCase			:     Any         =      images.shape[0]

															# Convert shape from [num examples, rows, columns, depth]
															# to [num examples, rows*columns] (assuming depth == 1)
															if reshape:
																						assert images.shape[3] == 1
																						__UpperCamelCase			:     Union[str, Any]         =      images.reshape(
																						    images.shape[0]  ,     images.shape[1] * images.shape[2]		)
															if dtype == dtypes.floataa:
																						# Convert from [0, 255] -> [0.0, 1.0].
																						__UpperCamelCase			:     List[Any]         =      images.astype(numpy.floataa		)
																						__UpperCamelCase			:     Optional[Any]         =      numpy.multiply(a  ,     1.0 / 255.0		)
								__UpperCamelCase			:     Optional[Any]         =      images
								__UpperCamelCase			:     List[Any]         =      labels
								__UpperCamelCase			:     str         =      0
								__UpperCamelCase			:     Union[str, Any]         =      0







	@property
	def      _lowerCamelCase       (      self	:Any		)	->				Any:
								return self._images







	@property
	def      _lowerCamelCase       (      self	:Any		)	->				Dict:
								return self._labels







	@property
	def      _lowerCamelCase       (      self	:List[str]		)	->				str:
								return self._num_examples







	@property
	def      _lowerCamelCase       (      self	:Tuple		)	->				Dict:
								return self._epochs_completed







	def      _lowerCamelCase       (      self	:Any  ,     a	:Optional[int]  ,     a	:Optional[int]=False  ,     a	:int=True		)	->				Optional[int]:
								if fake_data:
															__UpperCamelCase			:     Any         =      [1] * 7_8_4
															__UpperCamelCase			:     Union[str, Any]         =      [1] + [0] * 9 if self.one_hot else 0
															return (
															    [fake_image for _ in range(a		)],
															    [fake_label for _ in range(a		)],
															)
								__UpperCamelCase			:     str         =      self._index_in_epoch
								# Shuffle for the first epoch
								if self._epochs_completed == 0 and start == 0 and shuffle:
															__UpperCamelCase			:     Any         =      numpy.arange(self._num_examples		)
															numpy.random.shuffle(a		)
															__UpperCamelCase			:     int         =      self.images[perma]
															__UpperCamelCase			:     str         =      self.labels[perma]
								# Go to the next epoch
								if start + batch_size > self._num_examples:
															# Finished epoch
															self._epochs_completed += 1
															# Get the rest examples in this epoch
															__UpperCamelCase			:     Optional[int]         =      self._num_examples - start
															__UpperCamelCase			:     Optional[int]         =      self._images[start : self._num_examples]
															__UpperCamelCase			:     int         =      self._labels[start : self._num_examples]
															# Shuffle the data
															if shuffle:
																						__UpperCamelCase			:     Optional[int]         =      numpy.arange(self._num_examples		)
																						numpy.random.shuffle(a		)
																						__UpperCamelCase			:     Optional[Any]         =      self.images[perm]
																						__UpperCamelCase			:     Tuple         =      self.labels[perm]
															# Start next epoch
															__UpperCamelCase			:     Tuple         =      0
															__UpperCamelCase			:     Union[str, Any]         =      batch_size - rest_num_examples
															__UpperCamelCase			:     List[str]         =      self._index_in_epoch
															__UpperCamelCase			:     Dict         =      self._images[start:end]
															__UpperCamelCase			:     str         =      self._labels[start:end]
															return (
															    numpy.concatenate((images_rest_part, images_new_part)  ,     axis=0		),
															    numpy.concatenate((labels_rest_part, labels_new_part)  ,     axis=0		),
															)
								else:
															self._index_in_epoch += batch_size
															__UpperCamelCase			:     Union[str, Any]         =      self._index_in_epoch
															return self._images[start:end], self._labels[start:end]




@deprecated(_lowerCamelCase		,						"Please write your own downloading logic.")
def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    Tuple		,						_lowerCamelCase				:    Union[str, Any]		,						_lowerCamelCase				:    Union[str, Any])      ->					Tuple:






							'''simple docstring'''





							if not gfile.Exists(_lowerCamelCase):
														gfile.MakeDirs(_lowerCamelCase)
							__UpperCamelCase			:     Optional[Any]         =      os.path.join(_lowerCamelCase		,						_lowerCamelCase)
							if not gfile.Exists(_lowerCamelCase):
														urllib.request.urlretrieve(_lowerCamelCase		,						_lowerCamelCase)  # noqa: S310
														with gfile.GFile(_lowerCamelCase) as f:
																					__UpperCamelCase			:     Any         =      f.size()
														print("Successfully downloaded"		,						_lowerCamelCase		,						_lowerCamelCase		,						"bytes.")
							return filepath




@deprecated(
    _lowerCamelCase		,						"Please use alternatives such as:" " tensorflow_datasets.load('mnist')")
def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    str		,						_lowerCamelCase				:    List[Any]=False		,						_lowerCamelCase				:    str=False		,						_lowerCamelCase				:    List[str]=dtypes.floataa		,						_lowerCamelCase				:    Any=True		,						_lowerCamelCase				:    Union[str, Any]=5_000		,						_lowerCamelCase				:    str=None		,						_lowerCamelCase				:    Optional[int]=DEFAULT_SOURCE_URL		,						)      ->					List[Any]:






							'''simple docstring'''





							if fake_data:

														def fake():
																					return _DataSet(
																					    []		,						[]		,						fake_data=_lowerCamelCase		,						one_hot=_lowerCamelCase		,						dtype=_lowerCamelCase		,						seed=_lowerCamelCase)

														__UpperCamelCase			:     Optional[int]         =      fake()
														__UpperCamelCase			:     Tuple         =      fake()
														__UpperCamelCase			:     List[str]         =      fake()
														return _Datasets(train=_lowerCamelCase		,						validation=_lowerCamelCase		,						test=_lowerCamelCase)

							if not source_url:  # empty string check
														__UpperCamelCase			:     str         =      DEFAULT_SOURCE_URL

							__UpperCamelCase			:     Optional[int]         =      "train-images-idx3-ubyte.gz"
							__UpperCamelCase			:     Dict         =      "train-labels-idx1-ubyte.gz"
							__UpperCamelCase			:     List[str]         =      "t10k-images-idx3-ubyte.gz"
							__UpperCamelCase			:     List[str]         =      "t10k-labels-idx1-ubyte.gz"

							__UpperCamelCase			:     Optional[int]         =      _maybe_download(
							    _lowerCamelCase		,						_lowerCamelCase		,						source_url + train_images_file)
							with gfile.Open(_lowerCamelCase		,						"rb") as f:
														__UpperCamelCase			:     int         =      _extract_images(_lowerCamelCase)

							__UpperCamelCase			:     Optional[Any]         =      _maybe_download(
							    _lowerCamelCase		,						_lowerCamelCase		,						source_url + train_labels_file)
							with gfile.Open(_lowerCamelCase		,						"rb") as f:
														__UpperCamelCase			:     int         =      _extract_labels(_lowerCamelCase		,						one_hot=_lowerCamelCase)

							__UpperCamelCase			:     int         =      _maybe_download(
							    _lowerCamelCase		,						_lowerCamelCase		,						source_url + test_images_file)
							with gfile.Open(_lowerCamelCase		,						"rb") as f:
														__UpperCamelCase			:     Optional[int]         =      _extract_images(_lowerCamelCase)

							__UpperCamelCase			:     str         =      _maybe_download(
							    _lowerCamelCase		,						_lowerCamelCase		,						source_url + test_labels_file)
							with gfile.Open(_lowerCamelCase		,						"rb") as f:
														__UpperCamelCase			:     List[str]         =      _extract_labels(_lowerCamelCase		,						one_hot=_lowerCamelCase)

							if not 0 <= validation_size <= len(_lowerCamelCase):
														__UpperCamelCase			:     str         =      (
														    "Validation size should be between 0 and "
														    F'{len(_lowerCamelCase)}. Received: {validation_size}.'
														)
														raise ValueError(_lowerCamelCase)

							__UpperCamelCase			:     Any         =      train_images[:validation_size]
							__UpperCamelCase			:     Optional[Any]         =      train_labels[:validation_size]
							__UpperCamelCase			:     Optional[int]         =      train_images[validation_size:]
							__UpperCamelCase			:     Tuple         =      train_labels[validation_size:]

							__UpperCamelCase			:     List[str]         =      {"dtype": dtype, "reshape": reshape, "seed": seed}

							__UpperCamelCase			:     Union[str, Any]         =      _DataSet(_lowerCamelCase		,						_lowerCamelCase		,						**_lowerCamelCase)
							__UpperCamelCase			:     str         =      _DataSet(_lowerCamelCase		,						_lowerCamelCase		,						**_lowerCamelCase)
							__UpperCamelCase			:     Optional[Any]         =      _DataSet(_lowerCamelCase		,						_lowerCamelCase		,						**_lowerCamelCase)

							return _Datasets(train=_lowerCamelCase		,						validation=_lowerCamelCase		,						test=_lowerCamelCase)