





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


a_ =			"\\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"

a_ =			"\\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"

a_ =			"\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 		__snake_case					(		datasets.Metric     ):





 """simple docstring"""


 def 					UpperCamelCase__(    self  ):



     '''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 					UpperCamelCase__(    self					,						__lowerCamelCase					,						__lowerCamelCase					,						__lowerCamelCase=None					,						__lowerCamelCase=None					,						__lowerCamelCase=None					,						__lowerCamelCase=None					,						__lowerCamelCase="auto"					,						__lowerCamelCase=-1					,						__lowerCamelCase=0.9					,						__lowerCamelCase=5					,						__lowerCamelCase=500					,						__lowerCamelCase="gpt2-large"					,						__lowerCamelCase=-1					,						__lowerCamelCase=1024					,						__lowerCamelCase=25					,						__lowerCamelCase=5					,						__lowerCamelCase=True					,						__lowerCamelCase=25					,						):



     '''simple docstring'''




     __A    :						List[Any]						 =     compute_mauve(
         p_text=__SCREAMING_SNAKE_CASE					,						q_text=__SCREAMING_SNAKE_CASE					,						p_features=__SCREAMING_SNAKE_CASE					,						q_features=__SCREAMING_SNAKE_CASE					,						p_tokens=__SCREAMING_SNAKE_CASE					,						q_tokens=__SCREAMING_SNAKE_CASE					,						num_buckets=__SCREAMING_SNAKE_CASE					,						pca_max_data=__SCREAMING_SNAKE_CASE					,						kmeans_explained_var=__SCREAMING_SNAKE_CASE					,						kmeans_num_redo=__SCREAMING_SNAKE_CASE					,						kmeans_max_iter=__SCREAMING_SNAKE_CASE					,						featurize_model_name=__SCREAMING_SNAKE_CASE					,						device_id=__SCREAMING_SNAKE_CASE					,						max_text_length=__SCREAMING_SNAKE_CASE					,						divergence_curve_discretization_size=__SCREAMING_SNAKE_CASE					,						mauve_scaling_factor=__SCREAMING_SNAKE_CASE					,						verbose=__SCREAMING_SNAKE_CASE					,						seed=__SCREAMING_SNAKE_CASE					,						)
     return out






'''simple docstring'''







from pathlib import Path
from typing import List

from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import get_tests_dir, is_tool_test
from transformers.tools.agent_types import AGENT_TYPE_MAPPING, AgentAudio, AgentImage, AgentText


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image


_lowercase :  List[str]    							=       ["text", "image", "audio"]
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: List[str]							):



						"""simple docstring"""





						lowercase_	:     int													=       []

						for input_type in input_types:
												if input_type == "text":
																		inputs.append('''Text input'''							)
												elif input_type == "image":
																		inputs.append(
																		    Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO'''							)							) / '''000000039769.png'''							).resize((512, 512)							)							)
												elif input_type == "audio":
																		inputs.append(torch.ones(3000							)							)
												elif isinstance(__SCREAMING_SNAKE_CASE      ,      __SCREAMING_SNAKE_CASE							):
																		inputs.append(create_inputs(__SCREAMING_SNAKE_CASE							)							)
												else:
																		raise ValueError(F'''Invalid type requested: {input_type}'''							)

						return inputs
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: List							):



						"""simple docstring"""





						lowercase_	:     Optional[Any]													=       []

						for output in outputs:
												if isinstance(__SCREAMING_SNAKE_CASE      ,      (str, AgentText)							):
																		output_types.append('''text'''							)
												elif isinstance(__SCREAMING_SNAKE_CASE      ,      (Image.Image, AgentImage)							):
																		output_types.append('''image'''							)
												elif isinstance(__SCREAMING_SNAKE_CASE      ,      (torch.Tensor, AgentAudio)							):
																		output_types.append('''audio'''							)
												else:
																		raise ValueError(F'''Invalid output: {output}'''							)

						return output_types






@is_tool_test
class  lowerCAmelCase__   :






					def 	_snake_case    (   self		):


											"""simple docstring"""





											self.assertTrue(hasattr(self.tool				,							'''inputs'''		)		)
											self.assertTrue(hasattr(self.tool				,							'''outputs'''		)		)

											lowercase_	:     Optional[Any]													=       self.tool.inputs
											for _input in inputs:
																	if isinstance(_input				,							__SCREAMING_SNAKE_CASE		):
																							for __input in _input:
																													self.assertTrue(__input in authorized_types		)
																	else:
																							self.assertTrue(_input in authorized_types		)

											lowercase_	:     int													=       self.tool.outputs
											for _output in outputs:
																	self.assertTrue(_output in authorized_types		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     int													=       create_inputs(self.tool.inputs		)
											lowercase_	:     Tuple													=       self.tool(*__SCREAMING_SNAKE_CASE		)

											# There is a single output
											if len(self.tool.outputs		) == 1:
																	lowercase_	:     Any													=       [outputs]

											self.assertListEqual(output_types(__SCREAMING_SNAKE_CASE		)				,							self.tool.outputs		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											self.assertTrue(hasattr(self.tool				,							'''description'''		)		)
											self.assertTrue(hasattr(self.tool				,							'''default_checkpoint'''		)		)
											self.assertTrue(self.tool.description.startswith('''This is a tool that'''		)		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     int													=       create_inputs(self.tool.inputs		)
											lowercase_	:     int													=       self.tool(*__SCREAMING_SNAKE_CASE		)

											if not isinstance(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE		):
																	lowercase_	:     Optional[Any]													=       [outputs]

											self.assertEqual(len(__SCREAMING_SNAKE_CASE		)				,							len(self.tool.outputs		)		)

											for output, output_type in zip(__SCREAMING_SNAKE_CASE				,							self.tool.outputs		):
																	lowercase_	:     Optional[int]													=       AGENT_TYPE_MAPPING[output_type]
																	self.assertTrue(isinstance(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE		)		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     Dict													=       create_inputs(self.tool.inputs		)

											lowercase_	:     int													=       []

											for _input, input_type in zip(__SCREAMING_SNAKE_CASE				,							self.tool.inputs		):
																	if isinstance(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE		):
																							_inputs.append([AGENT_TYPE_MAPPING[_input_type](_input		) for _input_type in input_type]		)
																	else:
																							_inputs.append(AGENT_TYPE_MAPPING[input_type](_input		)		)

        # Should not raise an error
											lowercase_	:     Optional[Any]													=       self.tool(*__SCREAMING_SNAKE_CASE		)

											if not isinstance(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE		):
																	lowercase_	:     Dict													=       [outputs]

											self.assertEqual(len(__SCREAMING_SNAKE_CASE		)				,							len(self.tool.outputs		)		)



