






'''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


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

"""

__UpperCamelCase      :      Dict     						=						"""\
MAUVE is a library built on PyTorch and HuggingFace Transformers to measure the gap between neural text and human text with the eponymous MAUVE measure.

MAUVE summarizes both Type I and Type II errors measured softly using Kullback–Leibler (KL) divergences.

For details, see the MAUVE paper: https://arxiv.org/abs/2102.01454 (Neurips, 2021).

This metrics is a wrapper around the official implementation of MAUVE:
https://github.com/krishnap25/mauve
"""

__UpperCamelCase      :      Optional[int]     						=						"""
Calculates MAUVE scores between two lists of generated text and reference text.
Args:
    predictions: list of generated text to score. Each predictions
        should be a string with tokens separated by spaces.
    references: list of reference for each prediction. Each
        reference should be a string with tokens separated by spaces.
Optional Args:
    num_buckets: the size of the histogram to quantize P and Q. Options: 'auto' (default) or an integer
    pca_max_data: the number data points to use for PCA dimensionality reduction prior to clustering. If -1, use all the data. Default -1
    kmeans_explained_var: amount of variance of the data to keep in dimensionality reduction by PCA. Default 0.9
    kmeans_num_redo: number of times to redo k-means clustering (the best objective is kept). Default 5
    kmeans_max_iter: maximum number of k-means iterations. Default 500
    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'].
    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
    max_text_length: maximum number of tokens to consider. Default 1024
    divergence_curve_discretization_size: Number of points to consider on the divergence curve. Default 25
    mauve_scaling_factor: \"c\" from the paper. Default 5.
    verbose: If True (default), print running time updates
    seed: random seed to initialize k-means cluster assignments.
Returns:
    mauve: MAUVE score, a number between 0 and 1. Larger values indicate that P and Q are closer,
    frontier_integral: Frontier Integral, a number between 0 and 1. Smaller values indicate that P and Q are closer,
    divergence_curve: a numpy.ndarray of shape (m, 2); plot it with matplotlib to view the divergence curve,
    p_hist: a discrete distribution, which is a quantized version of the text distribution p_text,
    q_hist: same as above, but with q_text.
Examples:

    >>> # faiss segfaults in doctest for some reason, so the .compute call is not tested with doctest
    >>> import datasets
    >>> mauve = datasets.load_metric('mauve')
    >>> predictions = [\"hello there\", \"general kenobi\"]
    >>> references = [\"hello there\", \"general kenobi\"]
    >>> out = mauve.compute(predictions=predictions, references=references) # doctest: +SKIP
    >>> print(out.mauve) # doctest: +SKIP
    1.0
"""


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







	def  _a   (  self      :							Optional[int]			)		-> str:
		"""simple docstring"""







		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  _a   (  self      :							int       ,				_lowerCAmelCase      :							List[str]       ,				_lowerCAmelCase      :							List[str]       ,				_lowerCAmelCase      :							str=None       ,				_lowerCAmelCase      :							Dict=None       ,				_lowerCAmelCase      :							int=None       ,				_lowerCAmelCase      :							List[Any]=None       ,				_lowerCAmelCase      :							Optional[int]="auto"       ,				_lowerCAmelCase      :							Tuple=-1       ,				_lowerCAmelCase      :							Optional[int]=0.9       ,				_lowerCAmelCase      :							int=5       ,				_lowerCAmelCase      :							Tuple=500       ,				_lowerCAmelCase      :							List[Any]="gpt2-large"       ,				_lowerCAmelCase      :							List[str]=-1       ,				_lowerCAmelCase      :							List[Any]=1024       ,				_lowerCAmelCase      :							Any=25       ,				_lowerCAmelCase      :							List[Any]=5       ,				_lowerCAmelCase      :							List[Any]=True       ,				_lowerCAmelCase      :							Optional[int]=25       ,				)		-> Optional[int]:
		"""simple docstring"""







		__lowercase             =  compute_mauve(
		    p_text=_lowerCAmelCase       ,				q_text=_lowerCAmelCase       ,				p_features=_lowerCAmelCase       ,				q_features=_lowerCAmelCase       ,				p_tokens=_lowerCAmelCase       ,				q_tokens=_lowerCAmelCase       ,				num_buckets=_lowerCAmelCase       ,				pca_max_data=_lowerCAmelCase       ,				kmeans_explained_var=_lowerCAmelCase       ,				kmeans_num_redo=_lowerCAmelCase       ,				kmeans_max_iter=_lowerCAmelCase       ,				featurize_model_name=_lowerCAmelCase       ,				device_id=_lowerCAmelCase       ,				max_text_length=_lowerCAmelCase       ,				divergence_curve_discretization_size=_lowerCAmelCase       ,				mauve_scaling_factor=_lowerCAmelCase       ,				verbose=_lowerCAmelCase       ,				seed=_lowerCAmelCase       ,				)
		return out









import random
import unittest

import torch

from diffusers import IFInpaintingPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin


@skip_mps
class        __UpperCamelCase    (     _lowerCAmelCase   ,			_lowerCAmelCase   ,			unittest.TestCase   ):
	__snake_case	:Any   =       IFInpaintingPipeline
	__snake_case	:str   =       TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'width', 'height'}
	__snake_case	:Optional[int]   =       TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	__snake_case	:str   =       PipelineTesterMixin.required_optional_params - {'latents'}







	def  _a   (  self      :							Union[str, Any]			)		-> Tuple:
		"""simple docstring"""







		return self._get_dummy_components()







	def  _a   (  self      :							Optional[int]       ,				_lowerCAmelCase      :							List[str]       ,				_lowerCAmelCase      :							Dict=0			)		-> Any:
		"""simple docstring"""







		if str(_lowerCAmelCase			).startswith("""mps"""			):
			__lowercase             =  torch.manual_seed(_lowerCAmelCase			)
		else:
			__lowercase             =  torch.Generator(device=_lowerCAmelCase			).manual_seed(_lowerCAmelCase			)

		__lowercase             =  floats_tensor((1, 3, 32, 32)       ,				rng=random.Random(_lowerCAmelCase			)			).to(_lowerCAmelCase			)
		__lowercase             =  floats_tensor((1, 3, 32, 32)       ,				rng=random.Random(_lowerCAmelCase			)			).to(_lowerCAmelCase			)

		__lowercase             =  {
		    """prompt""": """A painting of a squirrel eating a burger""",
		    """image""": image,
		    """mask_image""": mask_image,
		    """generator""": generator,
		    """num_inference_steps""": 2,
		    """output_type""": """numpy""",
		}

		return inputs







	@unittest.skipIf(
	    torch_device != """cuda""" or not is_xformers_available()       ,				reason="""XFormers attention is only available with CUDA and `xformers` installed"""       ,				)
	def  _a   (  self      :							Tuple			)		-> Dict:
		"""simple docstring"""







		self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3			)







	def  _a   (  self      :							Union[str, Any]			)		-> Dict:
		"""simple docstring"""







		self._test_save_load_optional_components()







	@unittest.skipIf(torch_device != """cuda"""       ,				reason="""float16 requires CUDA"""			)
	def  _a   (  self      :							List[str]			)		-> Tuple:
		"""simple docstring"""







		super().test_save_load_floataa(expected_max_diff=1e-1			)







	def  _a   (  self      :							Tuple			)		-> Optional[Any]:
		"""simple docstring"""







		self._test_attention_slicing_forward_pass(expected_max_diff=1e-2			)







	def  _a   (  self      :							str			)		-> Optional[int]:
		"""simple docstring"""







		self._test_save_load_local()







	def  _a   (  self      :							List[str]			)		-> List[Any]:
		"""simple docstring"""







		self._test_inference_batch_single_identical(
		    expected_max_diff=1e-2       ,				)

