

"""simple docstring"""





import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import Callable, Dict, List, Tuple

import timm
import torch
import torch.nn as nn
from classy_vision.models.regnet import RegNet, RegNetParams, RegNetYaagf, RegNetYaagf, RegNetYaaagf
from huggingface_hub import cached_download, hf_hub_url
from torch import Tensor
from vissl.models.model_helpers import get_trunk_forward_outputs

from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel
from transformers.utils import logging


logging.set_verbosity_info()
_a       =							logging.get_logger()




@dataclass
class 					_lowerCAmelCase  :







 """simple docstring"""







 __UpperCAmelCase	:					nn.Module
 __UpperCAmelCase	:					List[nn.Module]   		=	field(default_factory=lowercase   )
 __UpperCAmelCase	:					list   		=	field(default_factory=lowercase   )


 def 					_lowercase (			self							:			Dict,					UpperCAmelCase__							:			Optional[Any],					UpperCAmelCase__							:			Tensor,					UpperCAmelCase__							:			Tensor	):
    __lowercase								=						len(list(m.modules()	)	) == 1 or isinstance(UpperCAmelCase__,					nn.Convad	) or isinstance(UpperCAmelCase__,					nn.BatchNormad	)
    if has_not_submodules:
       self.traced.append(UpperCAmelCase__	)


 def __call__(			self							:			Optional[Any],					UpperCAmelCase__							:			Tensor	):
    for m in self.module.modules():
       self.handles.append(m.register_forward_hook(self._forward_hook	)	)
    self.module(UpperCAmelCase__	)
    [x.remove() for x in self.handles]
    return self



 @property
 def 					_lowercase (			self							:			int	):
    # check the len of the state_dict keys to see if we have learnable params
    return list(filter(lambda UpperCAmelCase__	: len(list(x.state_dict().keys()	)	) > 0,					self.traced	)	)







@dataclass
class 					_lowerCAmelCase  :







 """simple docstring"""







 __UpperCAmelCase	:					nn.Module
 __UpperCAmelCase	:					nn.Module
 __UpperCAmelCase	:					int   		=	1
 __UpperCAmelCase	:					List   		=	field(default_factory=lowercase   )
 __UpperCAmelCase	:					List   		=	field(default_factory=lowercase   )
 __UpperCAmelCase	:					bool   		=	True


 def __call__(			self							:			str,					UpperCAmelCase__							:			Tensor	):
    __lowercase								=						Tracker(self.dest	)(UpperCAmelCase__	).parametrized
    __lowercase								=						Tracker(self.src	)(UpperCAmelCase__	).parametrized

    __lowercase								=						list(filter(lambda UpperCAmelCase__	: type(UpperCAmelCase__	) not in self.src_skip,					UpperCAmelCase__	)	)
    __lowercase								=						list(filter(lambda UpperCAmelCase__	: type(UpperCAmelCase__	) not in self.dest_skip,					UpperCAmelCase__	)	)

    if len(UpperCAmelCase__	) != len(UpperCAmelCase__	) and self.raise_if_mismatch:
       raise Exception(
           F"""Numbers of operations are different. Source module has {len(UpperCAmelCase__	)} operations while"""
           F""" destination module has {len(UpperCAmelCase__	)}."""	)

    for dest_m, src_m in zip(UpperCAmelCase__,					UpperCAmelCase__	):
       dest_m.load_state_dict(src_m.state_dict()	)
       if self.verbose == 1:
          print(F"""Transfered from={src_m} to={dest_m}"""	)







class 					_lowerCAmelCase  (	nn.Module   ):







 """simple docstring"""







 def __init__(			self							:			Any,					UpperCAmelCase__							:			nn.Module	):
    super().__init__()

    __lowercase								=						[]
    # - get the stem
    feature_blocks.append(("conv1", model.stem)	)
    # - get all the feature blocks
    for k, v in model.trunk_output.named_children():
       assert k.startswith("block"	), F"""Unexpected layer name {k}"""
       __lowercase								=						len(UpperCAmelCase__	) + 1
       feature_blocks.append((F"""res{block_index}""", v)	)

    __lowercase								=						nn.ModuleDict(UpperCAmelCase__	)



 def 					_lowercase (			self							:			Tuple,					UpperCAmelCase__							:			Tensor	):
    return get_trunk_forward_outputs(
        UpperCAmelCase__,					out_feat_keys=UpperCAmelCase__,					feature_blocks=self._feature_blocks,					)







class 					_lowerCAmelCase  (	lowercase   ):







 """simple docstring"""







 def 					_lowercase (			self							:			Dict,					UpperCAmelCase__							:			str	):
    __lowercase								=						x.split("-"	)
    return x_split[0] + x_split[1] + "_" + "".join(x_split[2:]	)



 def __getitem__(			self							:			List[Any],					UpperCAmelCase__							:			str	):
    # default to timm!
    if x not in self:
       __lowercase								=						self.convert_name_to_timm(UpperCAmelCase__	)
       __lowercase								=						partial(lambda: (timm.create_model(UpperCAmelCase__,					pretrained=UpperCAmelCase__	).eval(), None)	)

    else:
       __lowercase								=						super().__getitem__(UpperCAmelCase__	)

    return val







class 					_lowerCAmelCase  (	lowercase   ):







 """simple docstring"""







 def __getitem__(			self							:			str,					UpperCAmelCase__							:			str	):
    if "seer" in x and "in1k" not in x:
       __lowercase								=						RegNetModel
    else:
       __lowercase								=						RegNetForImageClassification
    return val







def   _A  (  UpperCamelCase_     :       Any,			UpperCamelCase_     :       Optional[int],			UpperCamelCase_     :       List[Tuple[str, str]])	->						List[Any]:
   '''simple docstring'''


   for from_key, to_key in keys:
      __lowercase								=						from_state_dict[from_key].clone()
      print(F"""Copied key={from_key} to={to_key}""")
   return to_state_dict




def   _A  (  UpperCamelCase_     :       str,			UpperCamelCase_     :       Callable[[], nn.Module],			UpperCamelCase_     :       Callable[[], nn.Module],			UpperCamelCase_     :       RegNetConfig,			UpperCamelCase_     :       Path,			UpperCamelCase_     :       bool = True,			)	->						Any:
   '''simple docstring'''


   print(F"""Converting {name}...""")
   with torch.no_grad():
      __lowercase		,__lowercase								=						from_model_func()
      __lowercase								=						our_model_func(UpperCamelCase_).eval()
      __lowercase								=						ModuleTransfer(src=UpperCamelCase_,			dest=UpperCamelCase_,			raise_if_mismatch=UpperCamelCase_)
      __lowercase								=						torch.randn((1, 3, 224, 224))
      module_transfer(UpperCamelCase_)

   if from_state_dict is not None:
      __lowercase								=						[]
      # for seer - in1k finetuned we have to manually copy the head
      if "seer" in name and "in1k" in name:
         __lowercase								=						[("0.clf.0.weight", "classifier.1.weight"), ("0.clf.0.bias", "classifier.1.bias")]
      __lowercase								=						manually_copy_vissl_head(UpperCamelCase_,			our_model.state_dict(),			UpperCamelCase_)
      our_model.load_state_dict(UpperCamelCase_)

   __lowercase								=						our_model(UpperCamelCase_,			output_hidden_states=UpperCamelCase_)
   __lowercase								=						(
       our_outputs.logits if isinstance(UpperCamelCase_,			UpperCamelCase_) else our_outputs.last_hidden_state
   )

   __lowercase								=						from_model(UpperCamelCase_)
   __lowercase								=						from_output[-1] if type(UpperCamelCase_) is list else from_output

   # now since I don't want to use any config files, vissl seer model doesn't actually have an head, so let's just check the last hidden state
   if "seer" in name and "in1k" in name:
      __lowercase								=						our_outputs.hidden_states[-1]

   assert torch.allclose(UpperCamelCase_,			UpperCamelCase_), "The model logits don't match the original one."

   if push_to_hub:
      our_model.push_to_hub(
          repo_path_or_name=save_directory / name,			commit_message="Add model",			use_temp_dir=UpperCamelCase_,			)

      __lowercase								=						224 if "seer" not in name else 384
      # we can use the convnext one
      __lowercase								=						AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k",			size=UpperCamelCase_)
      image_processor.push_to_hub(
          repo_path_or_name=save_directory / name,			commit_message="Add image processor",			use_temp_dir=UpperCamelCase_,			)

      print(F"""Pushed {name}""")




def   _A  (  UpperCamelCase_     :       Path,			UpperCamelCase_     :       str = None,			UpperCamelCase_     :       bool = True)	->						List[str]:
   '''simple docstring'''


   __lowercase								=						"imagenet-1k-id2label.json"
   __lowercase								=						1000
   __lowercase								=						(1, num_labels)

   __lowercase								=						"huggingface/label-files"
   __lowercase								=						num_labels
   __lowercase								=						json.load(open(cached_download(hf_hub_url(UpperCamelCase_,			UpperCamelCase_,			repo_type="dataset")),			"r"))
   __lowercase								=						{int(UpperCamelCase_): v for k, v in idalabel.items()}

   __lowercase								=						idalabel
   __lowercase								=						{v: k for k, v in idalabel.items()}

   __lowercase								=						partial(UpperCamelCase_,			num_labels=UpperCamelCase_,			idalabel=UpperCamelCase_,			labelaid=UpperCamelCase_)

   __lowercase								=						{
       "regnet-x-002": ImageNetPreTrainedConfig(
           depths=[1, 1, 4, 7],			hidden_sizes=[24, 56, 152, 368],			groups_width=8,			layer_type="x"),
       "regnet-x-004": ImageNetPreTrainedConfig(
           depths=[1, 2, 7, 12],			hidden_sizes=[32, 64, 160, 384],			groups_width=16,			layer_type="x"),
       "regnet-x-006": ImageNetPreTrainedConfig(
           depths=[1, 3, 5, 7],			hidden_sizes=[48, 96, 240, 528],			groups_width=24,			layer_type="x"),
       "regnet-x-008": ImageNetPreTrainedConfig(
           depths=[1, 3, 7, 5],			hidden_sizes=[64, 128, 288, 672],			groups_width=16,			layer_type="x"),
       "regnet-x-016": ImageNetPreTrainedConfig(
           depths=[2, 4, 10, 2],			hidden_sizes=[72, 168, 408, 912],			groups_width=24,			layer_type="x"),
       "regnet-x-032": ImageNetPreTrainedConfig(
           depths=[2, 6, 15, 2],			hidden_sizes=[96, 192, 432, 1008],			groups_width=48,			layer_type="x"),
       "regnet-x-040": ImageNetPreTrainedConfig(
           depths=[2, 5, 14, 2],			hidden_sizes=[80, 240, 560, 1360],			groups_width=40,			layer_type="x"),
       "regnet-x-064": ImageNetPreTrainedConfig(
           depths=[2, 4, 10, 1],			hidden_sizes=[168, 392, 784, 1624],			groups_width=56,			layer_type="x"),
       "regnet-x-080": ImageNetPreTrainedConfig(
           depths=[2, 5, 15, 1],			hidden_sizes=[80, 240, 720, 1920],			groups_width=120,			layer_type="x"),
       "regnet-x-120": ImageNetPreTrainedConfig(
           depths=[2, 5, 11, 1],			hidden_sizes=[224, 448, 896, 2240],			groups_width=112,			layer_type="x"),
       "regnet-x-160": ImageNetPreTrainedConfig(
           depths=[2, 6, 13, 1],			hidden_sizes=[256, 512, 896, 2048],			groups_width=128,			layer_type="x"),
       "regnet-x-320": ImageNetPreTrainedConfig(
           depths=[2, 7, 13, 1],			hidden_sizes=[336, 672, 1344, 2520],			groups_width=168,			layer_type="x"),
       # y variant
       "regnet-y-002": ImageNetPreTrainedConfig(depths=[1, 1, 4, 7],			hidden_sizes=[24, 56, 152, 368],			groups_width=8),
       "regnet-y-004": ImageNetPreTrainedConfig(
           depths=[1, 3, 6, 6],			hidden_sizes=[48, 104, 208, 440],			groups_width=8),
       "regnet-y-006": ImageNetPreTrainedConfig(
           depths=[1, 3, 7, 4],			hidden_sizes=[48, 112, 256, 608],			groups_width=16),
       "regnet-y-008": ImageNetPreTrainedConfig(
           depths=[1, 3, 8, 2],			hidden_sizes=[64, 128, 320, 768],			groups_width=16),
       "regnet-y-016": ImageNetPreTrainedConfig(
           depths=[2, 6, 17, 2],			hidden_sizes=[48, 120, 336, 888],			groups_width=24),
       "regnet-y-032": ImageNetPreTrainedConfig(
           depths=[2, 5, 13, 1],			hidden_sizes=[72, 216, 576, 1512],			groups_width=24),
       "regnet-y-040": ImageNetPreTrainedConfig(
           depths=[2, 6, 12, 2],			hidden_sizes=[128, 192, 512, 1088],			groups_width=64),
       "regnet-y-064": ImageNetPreTrainedConfig(
           depths=[2, 7, 14, 2],			hidden_sizes=[144, 288, 576, 1296],			groups_width=72),
       "regnet-y-080": ImageNetPreTrainedConfig(
           depths=[2, 4, 10, 1],			hidden_sizes=[168, 448, 896, 2016],			groups_width=56),
       "regnet-y-120": ImageNetPreTrainedConfig(
           depths=[2, 5, 11, 1],			hidden_sizes=[224, 448, 896, 2240],			groups_width=112),
       "regnet-y-160": ImageNetPreTrainedConfig(
           depths=[2, 4, 11, 1],			hidden_sizes=[224, 448, 1232, 3024],			groups_width=112),
       "regnet-y-320": ImageNetPreTrainedConfig(
           depths=[2, 5, 12, 1],			hidden_sizes=[232, 696, 1392, 3712],			groups_width=232),
       # models created by SEER -> https://arxiv.org/abs/2202.08360
       "regnet-y-320-seer": RegNetConfig(depths=[2, 5, 12, 1],			hidden_sizes=[232, 696, 1392, 3712],			groups_width=232),
       "regnet-y-640-seer": RegNetConfig(depths=[2, 5, 12, 1],			hidden_sizes=[328, 984, 1968, 4920],			groups_width=328),
       "regnet-y-1280-seer": RegNetConfig(
           depths=[2, 7, 17, 1],			hidden_sizes=[528, 1056, 2904, 7392],			groups_width=264),
       "regnet-y-2560-seer": RegNetConfig(
           depths=[3, 7, 16, 1],			hidden_sizes=[640, 1696, 2544, 5088],			groups_width=640),
       "regnet-y-10b-seer": ImageNetPreTrainedConfig(
           depths=[2, 7, 17, 1],			hidden_sizes=[2020, 4040, 11110, 28280],			groups_width=1010),
       # finetuned on imagenet
       "regnet-y-320-seer-in1k": ImageNetPreTrainedConfig(
           depths=[2, 5, 12, 1],			hidden_sizes=[232, 696, 1392, 3712],			groups_width=232),
       "regnet-y-640-seer-in1k": ImageNetPreTrainedConfig(
           depths=[2, 5, 12, 1],			hidden_sizes=[328, 984, 1968, 4920],			groups_width=328),
       "regnet-y-1280-seer-in1k": ImageNetPreTrainedConfig(
           depths=[2, 7, 17, 1],			hidden_sizes=[528, 1056, 2904, 7392],			groups_width=264),
       "regnet-y-2560-seer-in1k": ImageNetPreTrainedConfig(
           depths=[3, 7, 16, 1],			hidden_sizes=[640, 1696, 2544, 5088],			groups_width=640),
       "regnet-y-10b-seer-in1k": ImageNetPreTrainedConfig(
           depths=[2, 7, 17, 1],			hidden_sizes=[2020, 4040, 11110, 28280],			groups_width=1010),
   }

   __lowercase								=						NameToOurModelFuncMap()
   __lowercase								=						NameToFromModelFuncMap()
   # add seer weights logic

   def load_using_classy_vision(UpperCamelCase_     :       str,			UpperCamelCase_     :       Callable[[], nn.Module]) -> Tuple[nn.Module, Dict]:
      __lowercase								=						torch.hub.load_state_dict_from_url(UpperCamelCase_,			model_dir=str(UpperCamelCase_),			map_location="cpu")
      __lowercase								=						model_func()
      # check if we have a head, if yes add it
      __lowercase								=						files["classy_state_dict"]["base_model"]["model"]
      __lowercase								=						model_state_dict["trunk"]
      model.load_state_dict(UpperCamelCase_)
      return model.eval(), model_state_dict["heads"]

   # pretrained
   __lowercase								=						partial(
       UpperCamelCase_,			"https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet32d/seer_regnet32gf_model_iteration244000.torch",			lambda: FakeRegNetVisslWrapper(RegNetYaagf()),			)

   __lowercase								=						partial(
       UpperCamelCase_,			"https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet64/seer_regnet64gf_model_final_checkpoint_phase0.torch",			lambda: FakeRegNetVisslWrapper(RegNetYaagf()),			)

   __lowercase								=						partial(
       UpperCamelCase_,			"https://dl.fbaipublicfiles.com/vissl/model_zoo/swav_ig1b_regnet128Gf_cnstant_bs32_node16_sinkhorn10_proto16k_syncBN64_warmup8k/model_final_checkpoint_phase0.torch",			lambda: FakeRegNetVisslWrapper(RegNetYaaagf()),			)

   __lowercase								=						partial(
       UpperCamelCase_,			"https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch",			lambda: FakeRegNetVisslWrapper(
           RegNet(RegNetParams(depth=27,			group_width=1010,			w_a=1744,			w_a=620.83,			w_m=2.52))),			)

   # IN1K finetuned
   __lowercase								=						partial(
       UpperCamelCase_,			"https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet32_finetuned_in1k_model_final_checkpoint_phase78.torch",			lambda: FakeRegNetVisslWrapper(RegNetYaagf()),			)

   __lowercase								=						partial(
       UpperCamelCase_,			"https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet64_finetuned_in1k_model_final_checkpoint_phase78.torch",			lambda: FakeRegNetVisslWrapper(RegNetYaagf()),			)

   __lowercase								=						partial(
       UpperCamelCase_,			"https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet128_finetuned_in1k_model_final_checkpoint_phase78.torch",			lambda: FakeRegNetVisslWrapper(RegNetYaaagf()),			)

   __lowercase								=						partial(
       UpperCamelCase_,			"https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch",			lambda: FakeRegNetVisslWrapper(
           RegNet(RegNetParams(depth=27,			group_width=1010,			w_a=1744,			w_a=620.83,			w_m=2.52))),			)

   if model_name:
      convert_weight_and_push(
          UpperCamelCase_,			names_to_from_model_map[model_name],			names_to_ours_model_map[model_name],			names_to_config[model_name],			UpperCamelCase_,			UpperCamelCase_,			)
   else:
      for model_name, config in names_to_config.items():
         convert_weight_and_push(
             UpperCamelCase_,			names_to_from_model_map[model_name],			names_to_ours_model_map[model_name],			UpperCamelCase_,			UpperCamelCase_,			UpperCamelCase_,			)
   return config, expected_shape


if __name__ == "__main__":
   _a       =							argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--model_name',
       default=None,
       type=str,
       help=(
           'The name of the model you wish to convert, it must be one of the supported regnet* architecture,'
           ' currently: regnetx-*, regnety-*. If `None`, all of them will the converted.'
       ),
   )
   parser.add_argument(
       '--pytorch_dump_folder_path',
       default=None,
       type=Path,
       required=True,
       help='Path to the output PyTorch model directory.',
   )
   parser.add_argument(
       '--push_to_hub',
       default=True,
       type=bool,
       required=False,
       help='If True, push model and image processor to the hub.',
   )

   _a       =							parser.parse_args()

   _a       =							args.pytorch_dump_folder_path
   pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
   convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)







"""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 					_lowerCAmelCase  (	datasets.Metric   ):







 """simple docstring"""







 def 					_lowercase (			self							:			Dict	):
    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 					_lowercase (			self							:			Optional[Any],					UpperCAmelCase__							:			Optional[int],					UpperCAmelCase__							:			List[str],					UpperCAmelCase__							:			Optional[int]=False	):
    __lowercase								=						spearmanr(UpperCAmelCase__,					UpperCAmelCase__	)
    if return_pvalue:
       return {"spearmanr": results[0], "spearmanr_pvalue": results[1]}
    else:
       return {"spearmanr": results[0]}




