

"""simple docstring"""





import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.utils import (
    PIL_INTERPOLATION,
    randn_tensor,
)




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


   if isinstance(UpperCamelCase_,			torch.Tensor):
      return image
   elif isinstance(UpperCamelCase_,			PIL.Image.Image):
      __lowercase								=						[image]

   if isinstance(image[0],			PIL.Image.Image):
      __lowercase								=						[np.array(i.resize((w, h),			resample=PIL_INTERPOLATION["lanczos"]))[None, :] for i in image]
      __lowercase								=						np.concatenate(UpperCamelCase_,			axis=0)
      __lowercase								=						np.array(UpperCamelCase_).astype(np.floataa) / 255.0
      __lowercase								=						image.transpose(0,			3,			1,			2)
      __lowercase								=						2.0 * image - 1.0
      __lowercase								=						torch.from_numpy(UpperCamelCase_)
   elif isinstance(image[0],			torch.Tensor):
      __lowercase								=						torch.cat(UpperCamelCase_,			dim=0)
   return image




def   _A  (  UpperCamelCase_     :       Dict,			UpperCamelCase_     :       str,			UpperCamelCase_     :       Union[str, Any],			UpperCamelCase_     :       List[Any]=0.9_995)	->						int:
   '''simple docstring'''


   if not isinstance(UpperCamelCase_,			np.ndarray):
      __lowercase								=						True
      __lowercase								=						va.device
      __lowercase								=						va.cpu().numpy()
      __lowercase								=						va.cpu().numpy()

   __lowercase								=						np.sum(va * va / (np.linalg.norm(UpperCamelCase_) * np.linalg.norm(UpperCamelCase_)))
   if np.abs(UpperCamelCase_) > DOT_THRESHOLD:
      __lowercase								=						(1 - t) * va + t * va
   else:
      __lowercase								=						np.arccos(UpperCamelCase_)
      __lowercase								=						np.sin(UpperCamelCase_)
      __lowercase								=						theta_a * t
      __lowercase								=						np.sin(UpperCamelCase_)
      __lowercase								=						np.sin(theta_a - theta_t) / sin_theta_a
      __lowercase								=						sin_theta_t / sin_theta_a
      __lowercase								=						sa * va + sa * va

   if inputs_are_torch:
      __lowercase								=						torch.from_numpy(UpperCamelCase_).to(UpperCamelCase_)

   return va




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


   __lowercase								=						F.normalize(UpperCamelCase_,			dim=-1)
   __lowercase								=						F.normalize(UpperCamelCase_,			dim=-1)
   return (x - y).norm(dim=-1).div(2).arcsin().pow(2).mul(2)




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


   for param in model.parameters():
      __lowercase								=						value




class 					_lowerCAmelCase  (	lowercase   ):







 """simple docstring"""







 def __init__(			self							:			Dict,					UpperCAmelCase__							:			AutoencoderKL,					UpperCAmelCase__							:			CLIPTextModel,					UpperCAmelCase__							:			CLIPModel,					UpperCAmelCase__							:			CLIPTokenizer,					UpperCAmelCase__							:			UNetaDConditionModel,					UpperCAmelCase__							:			Union[PNDMScheduler, LMSDiscreteScheduler, DDIMScheduler, DPMSolverMultistepScheduler],					UpperCAmelCase__							:			CLIPFeatureExtractor,					UpperCAmelCase__							:			Union[str, Any]=None,					UpperCAmelCase__							:			List[str]=None,					UpperCAmelCase__							:			Any=None,					):
    super().__init__()
    self.register_modules(
        vae=UpperCAmelCase__,					text_encoder=UpperCAmelCase__,					clip_model=UpperCAmelCase__,					tokenizer=UpperCAmelCase__,					unet=UpperCAmelCase__,					scheduler=UpperCAmelCase__,					feature_extractor=UpperCAmelCase__,					coca_model=UpperCAmelCase__,					coca_tokenizer=UpperCAmelCase__,					coca_transform=UpperCAmelCase__,					)
    __lowercase								=						(
        feature_extractor.size
        if isinstance(feature_extractor.size,					UpperCAmelCase__	)
        else feature_extractor.size["shortest_edge"]
    )
    __lowercase								=						transforms.Normalize(mean=feature_extractor.image_mean,					std=feature_extractor.image_std	)
    set_requires_grad(self.text_encoder,					UpperCAmelCase__	)
    set_requires_grad(self.clip_model,					UpperCAmelCase__	)


 def 					_lowercase (			self							:			Tuple,					UpperCAmelCase__							:			Optional[Union[str, int]] = "auto"	):
    if slice_size == "auto":
       # half the attention head size is usually a good trade-off between
       # speed and memory
       __lowercase								=						self.unet.config.attention_head_dim // 2
    self.unet.set_attention_slice(UpperCAmelCase__	)


 def 					_lowercase (			self							:			int	):
    self.enable_attention_slicing(UpperCAmelCase__	)


 def 					_lowercase (			self							:			str	):
    set_requires_grad(self.vae,					UpperCAmelCase__	)


 def 					_lowercase (			self							:			Any	):
    set_requires_grad(self.vae,					UpperCAmelCase__	)


 def 					_lowercase (			self							:			Union[str, Any]	):
    set_requires_grad(self.unet,					UpperCAmelCase__	)


 def 					_lowercase (			self							:			Any	):
    set_requires_grad(self.unet,					UpperCAmelCase__	)


 def 					_lowercase (			self							:			List[str],					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			Any,					UpperCAmelCase__							:			Optional[Any]	):
    # get the original timestep using init_timestep
    __lowercase								=						min(int(num_inference_steps * strength	),					UpperCAmelCase__	)

    __lowercase								=						max(num_inference_steps - init_timestep,					0	)
    __lowercase								=						self.scheduler.timesteps[t_start:]

    return timesteps, num_inference_steps - t_start


 def 					_lowercase (			self							:			List[str],					UpperCAmelCase__							:			Union[str, Any],					UpperCAmelCase__							:			Union[str, Any],					UpperCAmelCase__							:			Optional[Any],					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			Any,					UpperCAmelCase__							:			int=None	):
    if not isinstance(UpperCAmelCase__,					torch.Tensor	):
       raise ValueError(F"""`image` has to be of type `torch.Tensor` but is {type(UpperCAmelCase__	)}"""	)

    __lowercase								=						image.to(device=UpperCAmelCase__,					dtype=UpperCAmelCase__	)

    if isinstance(UpperCAmelCase__,					UpperCAmelCase__	):
       __lowercase								=						[
           self.vae.encode(image[i : i + 1]	).latent_dist.sample(generator[i]	) for i in range(UpperCAmelCase__	)
       ]
       __lowercase								=						torch.cat(UpperCAmelCase__,					dim=0	)
    else:
       __lowercase								=						self.vae.encode(UpperCAmelCase__	).latent_dist.sample(UpperCAmelCase__	)

    # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
    __lowercase								=						0.18_215 * init_latents
    __lowercase								=						init_latents.repeat_interleave(UpperCAmelCase__,					dim=0	)

    __lowercase								=						randn_tensor(init_latents.shape,					generator=UpperCAmelCase__,					device=UpperCAmelCase__,					dtype=UpperCAmelCase__	)

    # get latents
    __lowercase								=						self.scheduler.add_noise(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						init_latents

    return latents


 def 					_lowercase (			self							:			Optional[int],					UpperCAmelCase__							:			Dict	):
    __lowercase								=						self.coca_transform(UpperCAmelCase__	).unsqueeze(0	)
    with torch.no_grad(), torch.cuda.amp.autocast():
       __lowercase								=						self.coca_model.generate(transformed_image.to(device=self.device,					dtype=self.coca_model.dtype	)	)
    __lowercase								=						self.coca_tokenizer.decode(generated[0].cpu().numpy()	)
    return generated.split("<end_of_text>"	)[0].replace("<start_of_text>",					""	).rstrip(" .,"	)


 def 					_lowercase (			self							:			Tuple,					UpperCAmelCase__							:			Union[str, Any],					UpperCAmelCase__							:			Tuple	):
    __lowercase								=						self.feature_extractor.preprocess(UpperCAmelCase__	)
    __lowercase								=						torch.from_numpy(clip_image_input["pixel_values"][0]	).unsqueeze(0	).to(self.device	).half()
    __lowercase								=						self.clip_model.get_image_features(UpperCAmelCase__	)
    __lowercase								=						image_embeddings_clip / image_embeddings_clip.norm(p=2,					dim=-1,					keepdim=UpperCAmelCase__	)
    __lowercase								=						image_embeddings_clip.repeat_interleave(UpperCAmelCase__,					dim=0	)
    return image_embeddings_clip


 @torch.enable_grad()
 def 					_lowercase (			self							:			str,					UpperCAmelCase__							:			List[Any],					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			List[str],					UpperCAmelCase__							:			Dict,					UpperCAmelCase__							:			List[str],					UpperCAmelCase__							:			Union[str, Any],					UpperCAmelCase__							:			Optional[int],					):
    __lowercase								=						latents.detach().requires_grad_()

    __lowercase								=						self.scheduler.scale_model_input(UpperCAmelCase__,					UpperCAmelCase__	)

    # predict the noise residual
    __lowercase								=						self.unet(UpperCAmelCase__,					UpperCAmelCase__,					encoder_hidden_states=UpperCAmelCase__	).sample

    if isinstance(self.scheduler,					(PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)	):
       __lowercase								=						self.scheduler.alphas_cumprod[timestep]
       __lowercase								=						1 - alpha_prod_t
       # compute predicted original sample from predicted noise also called
       # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
       __lowercase								=						(latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

       __lowercase								=						torch.sqrt(UpperCAmelCase__	)
       __lowercase								=						pred_original_sample * (fac) + latents * (1 - fac)
    elif isinstance(self.scheduler,					UpperCAmelCase__	):
       __lowercase								=						self.scheduler.sigmas[index]
       __lowercase								=						latents - sigma * noise_pred
    else:
       raise ValueError(F"""scheduler type {type(self.scheduler	)} not supported"""	)

    # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
    __lowercase								=						1 / 0.18_215 * sample
    __lowercase								=						self.vae.decode(UpperCAmelCase__	).sample
    __lowercase								=						(image / 2 + 0.5).clamp(0,					1	)

    __lowercase								=						transforms.Resize(self.feature_extractor_size	)(UpperCAmelCase__	)
    __lowercase								=						self.normalize(UpperCAmelCase__	).to(latents.dtype	)

    __lowercase								=						self.clip_model.get_image_features(UpperCAmelCase__	)
    __lowercase								=						image_embeddings_clip / image_embeddings_clip.norm(p=2,					dim=-1,					keepdim=UpperCAmelCase__	)

    __lowercase								=						spherical_dist_loss(UpperCAmelCase__,					UpperCAmelCase__	).mean() * clip_guidance_scale

    __lowercase								=						-torch.autograd.grad(UpperCAmelCase__,					UpperCAmelCase__	)[0]

    if isinstance(self.scheduler,					UpperCAmelCase__	):
       __lowercase								=						latents.detach() + grads * (sigma**2)
       __lowercase								=						noise_pred_original
    else:
       __lowercase								=						noise_pred_original - torch.sqrt(UpperCAmelCase__	) * grads
    return noise_pred, latents



 @torch.no_grad()
 def __call__(			self							:			str,					UpperCAmelCase__							:			Union[torch.FloatTensor, PIL.Image.Image],					UpperCAmelCase__							:			Union[torch.FloatTensor, PIL.Image.Image],					UpperCAmelCase__							:			Optional[str] = None,					UpperCAmelCase__							:			Optional[str] = None,					UpperCAmelCase__							:			Optional[int] = 5_1_2,					UpperCAmelCase__							:			Optional[int] = 5_1_2,					UpperCAmelCase__							:			float = 0.6,					UpperCAmelCase__							:			Optional[int] = 5_0,					UpperCAmelCase__							:			Optional[float] = 7.5,					UpperCAmelCase__							:			Optional[int] = 1,					UpperCAmelCase__							:			float = 0.0,					UpperCAmelCase__							:			Optional[float] = 1_0_0,					UpperCAmelCase__							:			Optional[torch.Generator] = None,					UpperCAmelCase__							:			Optional[str] = "pil",					UpperCAmelCase__							:			bool = True,					UpperCAmelCase__							:			float = 0.8,					UpperCAmelCase__							:			float = 0.1,					UpperCAmelCase__							:			float = 0.1,					):
    if isinstance(UpperCAmelCase__,					UpperCAmelCase__	) and len(UpperCAmelCase__	) != batch_size:
       raise ValueError(F"""You have passed {batch_size} batch_size, but only {len(UpperCAmelCase__	)} generators."""	)

    if height % 8 != 0 or width % 8 != 0:
       raise ValueError(F"""`height` and `width` have to be divisible by 8 but are {height} and {width}."""	)

    if isinstance(UpperCAmelCase__,					torch.Generator	) and batch_size > 1:
       __lowercase								=						[generator] + [None] * (batch_size - 1)

    __lowercase								=						[
        ("model", self.coca_model is None),
        ("tokenizer", self.coca_tokenizer is None),
        ("transform", self.coca_transform is None),
    ]
    __lowercase								=						[x[0] for x in coca_is_none if x[1]]
    __lowercase								=						", ".join(UpperCAmelCase__	)
    # generate prompts with coca model if prompt is None
    if content_prompt is None:
       if len(UpperCAmelCase__	):
          raise ValueError(
              F"""Content prompt is None and CoCa [{coca_is_none_str}] is None."""
              F"""Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline."""	)
       __lowercase								=						self.get_image_description(UpperCAmelCase__	)
    if style_prompt is None:
       if len(UpperCAmelCase__	):
          raise ValueError(
              F"""Style prompt is None and CoCa [{coca_is_none_str}] is None."""
              F""" Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline."""	)
       __lowercase								=						self.get_image_description(UpperCAmelCase__	)

    # get prompt text embeddings for content and style
    __lowercase								=						self.tokenizer(
        UpperCAmelCase__,					padding="max_length",					max_length=self.tokenizer.model_max_length,					truncation=UpperCAmelCase__,					return_tensors="pt",					)
    __lowercase								=						self.text_encoder(content_text_input.input_ids.to(self.device	)	)[0]

    __lowercase								=						self.tokenizer(
        UpperCAmelCase__,					padding="max_length",					max_length=self.tokenizer.model_max_length,					truncation=UpperCAmelCase__,					return_tensors="pt",					)
    __lowercase								=						self.text_encoder(style_text_input.input_ids.to(self.device	)	)[0]

    __lowercase								=						slerp(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__	)

    # duplicate text embeddings for each generation per prompt
    __lowercase								=						text_embeddings.repeat_interleave(UpperCAmelCase__,					dim=0	)

    # set timesteps
    __lowercase								=						"offset" in set(inspect.signature(self.scheduler.set_timesteps	).parameters.keys()	)
    __lowercase								=						{}
    if accepts_offset:
       __lowercase								=						1

    self.scheduler.set_timesteps(UpperCAmelCase__,					**UpperCAmelCase__	)
    # Some schedulers like PNDM have timesteps as arrays
    # It's more optimized to move all timesteps to correct device beforehand
    self.scheduler.timesteps.to(self.device	)

    __lowercase		,__lowercase								=						self.get_timesteps(UpperCAmelCase__,					UpperCAmelCase__,					self.device	)
    __lowercase								=						timesteps[:1].repeat(UpperCAmelCase__	)

    # Preprocess image
    __lowercase								=						preprocess(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						self.prepare_latents(
        UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					text_embeddings.dtype,					self.device,					UpperCAmelCase__	)

    __lowercase								=						preprocess(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__	)
    __lowercase								=						self.prepare_latents(
        UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					text_embeddings.dtype,					self.device,					UpperCAmelCase__	)

    __lowercase								=						slerp(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__	)

    if clip_guidance_scale > 0:
       __lowercase								=						self.get_clip_image_embeddings(UpperCAmelCase__,					UpperCAmelCase__	)
       __lowercase								=						self.get_clip_image_embeddings(UpperCAmelCase__,					UpperCAmelCase__	)
       __lowercase								=						slerp(
           UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__	)

    # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
    # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
    # corresponds to doing no classifier free guidance.
    __lowercase								=						guidance_scale > 1.0
    # get unconditional embeddings for classifier free guidance
    if do_classifier_free_guidance:
       __lowercase								=						content_text_input.input_ids.shape[-1]
       __lowercase								=						self.tokenizer([""],					padding="max_length",					max_length=UpperCAmelCase__,					return_tensors="pt"	)
       __lowercase								=						self.text_encoder(uncond_input.input_ids.to(self.device	)	)[0]
       # duplicate unconditional embeddings for each generation per prompt
       __lowercase								=						uncond_embeddings.repeat_interleave(UpperCAmelCase__,					dim=0	)

       # For classifier free guidance, we need to do two forward passes.
       # Here we concatenate the unconditional and text embeddings into a single batch
       # to avoid doing two forward passes
       __lowercase								=						torch.cat([uncond_embeddings, text_embeddings]	)

    # get the initial random noise unless the user supplied it

    # Unlike in other pipelines, latents need to be generated in the target device
    # for 1-to-1 results reproducibility with the CompVis implementation.
    # However this currently doesn't work in `mps`.
    __lowercase								=						(batch_size, self.unet.config.in_channels, height // 8, width // 8)
    __lowercase								=						text_embeddings.dtype
    if latents is None:
       if self.device.type == "mps":
          # randn does not work reproducibly on mps
          __lowercase								=						torch.randn(UpperCAmelCase__,					generator=UpperCAmelCase__,					device="cpu",					dtype=UpperCAmelCase__	).to(
              self.device	)
       else:
          __lowercase								=						torch.randn(UpperCAmelCase__,					generator=UpperCAmelCase__,					device=self.device,					dtype=UpperCAmelCase__	)
    else:
       if latents.shape != latents_shape:
          raise ValueError(F"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}"""	)
       __lowercase								=						latents.to(self.device	)

    # scale the initial noise by the standard deviation required by the scheduler
    __lowercase								=						latents * self.scheduler.init_noise_sigma

    # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
    # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
    # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
    # and should be between [0, 1]
    __lowercase								=						"eta" in set(inspect.signature(self.scheduler.step	).parameters.keys()	)
    __lowercase								=						{}
    if accepts_eta:
       __lowercase								=						eta

    # check if the scheduler accepts generator
    __lowercase								=						"generator" in set(inspect.signature(self.scheduler.step	).parameters.keys()	)
    if accepts_generator:
       __lowercase								=						generator

    with self.progress_bar(total=UpperCAmelCase__	):
       for i, t in enumerate(UpperCAmelCase__	):
          # expand the latents if we are doing classifier free guidance
          __lowercase								=						torch.cat([latents] * 2	) if do_classifier_free_guidance else latents
          __lowercase								=						self.scheduler.scale_model_input(UpperCAmelCase__,					UpperCAmelCase__	)

          # predict the noise residual
          __lowercase								=						self.unet(UpperCAmelCase__,					UpperCAmelCase__,					encoder_hidden_states=UpperCAmelCase__	).sample

          # perform classifier free guidance
          if do_classifier_free_guidance:
             __lowercase		,__lowercase								=						noise_pred.chunk(2	)
             __lowercase								=						noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

          # perform clip guidance
          if clip_guidance_scale > 0:
             __lowercase								=						(
                 text_embeddings.chunk(2	)[1] if do_classifier_free_guidance else text_embeddings
             )
             __lowercase		,__lowercase								=						self.cond_fn(
                 UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					)

          # compute the previous noisy sample x_t -> x_t-1
          __lowercase								=						self.scheduler.step(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__,					**UpperCAmelCase__	).prev_sample

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
    __lowercase								=						1 / 0.18_215 * latents
    __lowercase								=						self.vae.decode(UpperCAmelCase__	).sample

    __lowercase								=						(image / 2 + 0.5).clamp(0,					1	)
    __lowercase								=						image.cpu().permute(0,					2,					3,					1	).numpy()

    if output_type == "pil":
       __lowercase								=						self.numpy_to_pil(UpperCAmelCase__	)

    if not return_dict:
       return (image, None)

    return StableDiffusionPipelineOutput(images=UpperCAmelCase__,					nsfw_content_detected=UpperCAmelCase__	)







"""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]}




