'''simple docstring'''




import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference





class     __magic_name__						(    _UpperCAmelCase,     unittest.TestCase):
			UpperCamelCase__				=       ShapEPipeline
			UpperCamelCase__				=       ['''prompt''']
			UpperCamelCase__				=       ['''prompt''']
			UpperCamelCase__				=       [
			    '''num_images_per_prompt''',
			    '''num_inference_steps''',
			    '''generator''',
			    '''latents''',
			    '''guidance_scale''',
			    '''frame_size''',
			    '''output_type''',
			    '''return_dict''',
			]
			UpperCamelCase__				=       False







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[Any]    ):
										return 32







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  Dict    ):
										return 32







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  Tuple    ):
										return self.time_input_dim * 4







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										return 8







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  Union[str, Any]    ):
										lowercase_					:			Union[str, Any]										=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )
										return tokenizer







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  Any    ):
										torch.manual_seed(0    )
										lowercase_					:			Any										=       CLIPTextConfig(
										    bos_token_id=0				,			eos_token_id=2				,			hidden_size=self.text_embedder_hidden_size				,			projection_dim=self.text_embedder_hidden_size				,			intermediate_size=37				,			layer_norm_eps=1E-05				,			num_attention_heads=4				,			num_hidden_layers=5				,			pad_token_id=1				,			vocab_size=1000				,			)
										return CLIPTextModelWithProjection(lowercase_    )







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[Any]    ):
										torch.manual_seed(0    )

										lowercase_					:			int										=       {
										    """num_attention_heads""": 2,
										    """attention_head_dim""": 16,
										    """embedding_dim""": self.time_input_dim,
										    """num_embeddings""": 32,
										    """embedding_proj_dim""": self.text_embedder_hidden_size,
										    """time_embed_dim""": self.time_embed_dim,
										    """num_layers""": 1,
										    """clip_embed_dim""": self.time_input_dim * 2,
										    """additional_embeddings""": 0,
										    """time_embed_act_fn""": """gelu""",
										    """norm_in_type""": """layer""",
										    """encoder_hid_proj_type""": None,
										    """added_emb_type""": None,
										}

										lowercase_					:			Tuple										=       PriorTransformer(**lowercase_    )
										return model







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										torch.manual_seed(0    )

										lowercase_					:			Tuple										=       {
										    """param_shapes""": (
										        (self.renderer_dim, 93),
										        (self.renderer_dim, 8),
										        (self.renderer_dim, 8),
										        (self.renderer_dim, 8),
										    ),
										    """d_latent""": self.time_input_dim,
										    """d_hidden""": self.renderer_dim,
										    """n_output""": 12,
										    """background""": (
										        0.1,
										        0.1,
										        0.1,
										    ),
										}
										lowercase_					:			Dict										=       ShapERenderer(**lowercase_    )
										return model







			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										lowercase_					:			Optional[Any]										=       self.dummy_prior
										lowercase_					:			str										=       self.dummy_text_encoder
										lowercase_					:			int										=       self.dummy_tokenizer
										lowercase_					:			Union[str, Any]										=       self.dummy_renderer

										lowercase_					:			Dict										=       HeunDiscreteScheduler(
										    beta_schedule="""exp"""				,			num_train_timesteps=1024				,			prediction_type="""sample"""				,			use_karras_sigmas=lowercase_				,			clip_sample=lowercase_				,			clip_sample_range=1.0				,			)
										lowercase_					:			Any										=       {
										    """prior""": prior,
										    """text_encoder""": text_encoder,
										    """tokenizer""": tokenizer,
										    """renderer""": renderer,
										    """scheduler""": scheduler,
										}

										return components







			def 	SCREAMING_SNAKE_CASE_     (	self				:  str				,			lowercase_				:  Tuple				,			lowercase_				:  Tuple=0    ):
										if str(lowercase_    ).startswith("""mps"""    ):
																	lowercase_					:			Any										=       torch.manual_seed(lowercase_    )
										else:
																	lowercase_					:			Dict										=       torch.Generator(device=lowercase_    ).manual_seed(lowercase_    )
										lowercase_					:			Optional[Any]										=       {
										    """prompt""": """horse""",
										    """generator""": generator,
										    """num_inference_steps""": 1,
										    """frame_size""": 32,
										    """output_type""": """np""",
										}
										return inputs







			def 	SCREAMING_SNAKE_CASE_     (	self				:  int    ):
										lowercase_					:			Optional[Any]										=       """cpu"""

										lowercase_					:			Dict										=       self.get_dummy_components()

										lowercase_					:			Union[str, Any]										=       self.pipeline_class(**lowercase_    )
										lowercase_					:			str										=       pipe.to(lowercase_    )

										pipe.set_progress_bar_config(disable=lowercase_    )

										lowercase_					:			int										=       pipe(**self.get_dummy_inputs(lowercase_    )    )
										lowercase_					:			Optional[int]										=       output.images[0]
										lowercase_					:			Optional[int]										=       image[0, -3:, -3:, -1]

										assert image.shape == (20, 32, 32, 3)

										lowercase_					:			Optional[Any]										=       np.array(
										    [
										        0.00_03_92_16,
										        0.00_03_92_16,
										        0.00_03_92_16,
										        0.00_03_92_16,
										        0.00_03_92_16,
										        0.00_03_92_16,
										        0.00_03_92_16,
										        0.00_03_92_16,
										        0.00_03_92_16,
										    ]    )

										assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Dict    ):
										# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
										self._test_inference_batch_consistent(batch_sizes=[1, 2]    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Union[str, Any]    ):
										lowercase_					:			int										=       torch_device == """cpu"""
										lowercase_					:			Any										=       True

										self._test_inference_batch_single_identical(
										    batch_size=2				,			test_max_difference=lowercase_				,			relax_max_difference=lowercase_				,			)







			def 	SCREAMING_SNAKE_CASE_     (	self				:  str    ):
										lowercase_					:			List[Any]										=       self.get_dummy_components()
										lowercase_					:			int										=       self.pipeline_class(**lowercase_    )
										lowercase_					:			Any										=       pipe.to(lowercase_    )
										pipe.set_progress_bar_config(disable=lowercase_    )

										lowercase_					:			str										=       1
										lowercase_					:			List[str]										=       2

										lowercase_					:			Union[str, Any]										=       self.get_dummy_inputs(lowercase_    )

										for key in inputs.keys():
																	if key in self.batch_params:
																								lowercase_					:			List[str]										=       batch_size * [inputs[key]]

										lowercase_					:			str										=       pipe(**lowercase_				,			num_images_per_prompt=lowercase_    )[0]

										assert images.shape[0] == batch_size * num_images_per_prompt





@slow
@require_torch_gpu
class     __magic_name__						(    unittest.TestCase):







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Tuple    ):
										# clean up the VRAM after each test
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Any    ):
										lowercase_					:			Any										=       load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
										    """/shap_e/test_shap_e_np_out.npy"""    )
										lowercase_					:			Union[str, Any]										=       ShapEPipeline.from_pretrained("""openai/shap-e"""    )
										lowercase_					:			List[Any]										=       pipe.to(lowercase_    )
										pipe.set_progress_bar_config(disable=lowercase_    )

										lowercase_					:			Any										=       torch.Generator(device=lowercase_    ).manual_seed(0    )

										lowercase_					:			str										=       pipe(
										    """a shark"""				,			generator=lowercase_				,			guidance_scale=15.0				,			num_inference_steps=64				,			frame_size=64				,			output_type="""np"""				,			).images[0]

										assert images.shape == (20, 64, 64, 3)

										assert_mean_pixel_difference(lowercase_				,			lowercase_    )






'''simple docstring'''




import faiss  # noqa: F401 # Here to have a nice missing dependency error message early on
import numpy  # noqa: F401 # Here to have a nice missing dependency error message early on
import requests  # noqa: F401 # Here to have a nice missing dependency error message early on
import sklearn  # noqa: F401 # Here to have a nice missing dependency error message early on
import tqdm  # noqa: F401 # Here to have a nice missing dependency error message early on
from mauve import compute_mauve  # From: mauve-text

import datasets


_lowercase						: Optional[int]						=						"\\n@inproceedings{pillutla-etal:mauve:neurips2021,\n  title={MAUVE: Measuring the Gap Between Neural Text and Human Text using Divergence Frontiers},\n  author={Pillutla, Krishna and Swayamdipta, Swabha and Zellers, Rowan and Thickstun, John and Welleck, Sean and Choi, Yejin and Harchaoui, Zaid},\n  booktitle = {NeurIPS},\n  year      = {2021}\n}\n\n"

_lowercase						: List[Any]						=						"\\nMAUVE is a library built on PyTorch and HuggingFace Transformers to measure the gap between neural text and human text with the eponymous MAUVE measure.\n\nMAUVE summarizes both Type I and Type II errors measured softly using Kullback–Leibler (KL) divergences.\n\nFor details, see the MAUVE paper: https://arxiv.org/abs/2102.01454 (Neurips, 2021).\n\nThis metrics is a wrapper around the official implementation of MAUVE:\nhttps://github.com/krishnap25/mauve\n"

_lowercase						: List[Any]						=						"\nCalculates MAUVE scores between two lists of generated text and reference text.\nArgs:\n    predictions: list of generated text to score. Each predictions\n        should be a string with tokens separated by spaces.\n    references: list of reference for each prediction. Each\n        reference should be a string with tokens separated by spaces.\nOptional Args:\n    num_buckets: the size of the histogram to quantize P and Q. Options: 'auto' (default) or an integer\n    pca_max_data: the number data points to use for PCA dimensionality reduction prior to clustering. If -1, use all the data. Default -1\n    kmeans_explained_var: amount of variance of the data to keep in dimensionality reduction by PCA. Default 0.9\n    kmeans_num_redo: number of times to redo k-means clustering (the best objective is kept). Default 5\n    kmeans_max_iter: maximum number of k-means iterations. Default 500\n    featurize_model_name: name of the model from which features are obtained. Default 'gpt2-large' Use one of ['gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'].\n    device_id: Device for featurization. Supply a GPU id (e.g. 0 or 3) to use GPU. If no GPU with this id is found, use CPU\n    max_text_length: maximum number of tokens to consider. Default 1024\n    divergence_curve_discretization_size: Number of points to consider on the divergence curve. Default 25\n    mauve_scaling_factor: \"c\" from the paper. Default 5.\n    verbose: If True (default), print running time updates\n    seed: random seed to initialize k-means cluster assignments.\nReturns:\n    mauve: MAUVE score, a number between 0 and 1. Larger values indicate that P and Q are closer,\n    frontier_integral: Frontier Integral, a number between 0 and 1. Smaller values indicate that P and Q are closer,\n    divergence_curve: a numpy.ndarray of shape (m, 2); plot it with matplotlib to view the divergence curve,\n    p_hist: a discrete distribution, which is a quantized version of the text distribution p_text,\n    q_hist: same as above, but with q_text.\nExamples:\n\n    >>> # faiss segfaults in doctest for some reason, so the .compute call is not tested with doctest\n    >>> import datasets\n    >>> mauve = datasets.load_metric('mauve')\n    >>> predictions = [\"hello there\", \"general kenobi\"]\n    >>> references = [\"hello there\", \"general kenobi\"]\n    >>> out = mauve.compute(predictions=predictions, references=references) # doctest: +SKIP\n    >>> print(out.mauve) # doctest: +SKIP\n    1.0\n"





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







			def 	SCREAMING_SNAKE_CASE_     (	self				:  List[Any]    ):
										return datasets.MetricInfo(
										    description=_DESCRIPTION				,			citation=_CITATION				,			homepage="""https://github.com/krishnap25/mauve"""				,			inputs_description=_KWARGS_DESCRIPTION				,			features=datasets.Features(
										        {
										            """predictions""": datasets.Value("""string"""				,			id="""sequence"""    ),
										            """references""": datasets.Value("""string"""				,			id="""sequence"""    ),
										        }    )				,			codebase_urls=["""https://github.com/krishnap25/mauve"""]				,			reference_urls=[
										        """https://arxiv.org/abs/2102.01454""",
										        """https://github.com/krishnap25/mauve""",
										    ]				,			)







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[int]				,			lowercase_				:  Union[str, Any]				,			lowercase_				:  Any				,			lowercase_				:  Any=None				,			lowercase_				:  str=None				,			lowercase_				:  Dict=None				,			lowercase_				:  Any=None				,			lowercase_				:  int="auto"				,			lowercase_				:  Tuple=-1				,			lowercase_				:  str=0.9				,			lowercase_				:  Union[str, Any]=5				,			lowercase_				:  List[str]=500				,			lowercase_				:  Union[str, Any]="gpt2-large"				,			lowercase_				:  List[Any]=-1				,			lowercase_				:  str=1024				,			lowercase_				:  List[str]=25				,			lowercase_				:  str=5				,			lowercase_				:  List[Any]=True				,			lowercase_				:  Tuple=25				,			):
										lowercase_					:			List[str]										=       compute_mauve(
										    p_text=lowercase_				,			q_text=lowercase_				,			p_features=lowercase_				,			q_features=lowercase_				,			p_tokens=lowercase_				,			q_tokens=lowercase_				,			num_buckets=lowercase_				,			pca_max_data=lowercase_				,			kmeans_explained_var=lowercase_				,			kmeans_num_redo=lowercase_				,			kmeans_max_iter=lowercase_				,			featurize_model_name=lowercase_				,			device_id=lowercase_				,			max_text_length=lowercase_				,			divergence_curve_discretization_size=lowercase_				,			mauve_scaling_factor=lowercase_				,			verbose=lowercase_				,			seed=lowercase_				,			)
										return out





