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



		def 						UpperCAmelCase							(					self)       ->       int:






							'''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				,		__a				,		__a				,		__a=None				,		__a=None				,		__a=None				,		__a=None				,		__a="auto"				,		__a=-1				,		__a=0.9				,		__a=5				,		__a=5_00				,		__a="gpt2-large"				,		__a=-1				,		__a=10_24				,		__a=25				,		__a=5				,		__a=True				,		__a=25				,		)       ->       Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  compute_mauve(
							    p_text=snake_case_				,		q_text=snake_case_				,		p_features=snake_case_				,		q_features=snake_case_				,		p_tokens=snake_case_				,		q_tokens=snake_case_				,		num_buckets=snake_case_				,		pca_max_data=snake_case_				,		kmeans_explained_var=snake_case_				,		kmeans_num_redo=snake_case_				,		kmeans_max_iter=snake_case_				,		featurize_model_name=snake_case_				,		device_id=snake_case_				,		max_text_length=snake_case_				,		divergence_curve_discretization_size=snake_case_				,		mauve_scaling_factor=snake_case_				,		verbose=snake_case_				,		seed=snake_case_				,		)
							return out








import string

# frequency taken from https://en.wikipedia.org/wiki/Letter_frequency
lowercase__       ={
    'E': 12.70,
    'T': 9.06,
    'A': 8.17,
    'O': 7.51,
    'I': 6.97,
    'N': 6.75,
    'S': 6.33,
    'H': 6.09,
    'R': 5.99,
    'D': 4.25,
    'L': 4.03,
    'C': 2.78,
    'U': 2.76,
    'M': 2.41,
    'W': 2.36,
    'F': 2.23,
    'G': 2.02,
    'Y': 1.97,
    'P': 1.93,
    'B': 1.29,
    'V': 0.98,
    'K': 0.77,
    'J': 0.15,
    'X': 0.15,
    'Q': 0.10,
    'Z': 0.07,
}
lowercase__       ='ETAOINSHRDLCUMWFGYPBVKJXQZ'
lowercase__       ='ABCDEFGHIJKLMNOPQRSTUVWXYZ'




def    __UpperCamelCase     (				lowerCAmelCase__							:				str  ):
 __a :  List[Any]						=  {letter: 0 for letter in string.ascii_uppercase}
 for letter in message.upper():
  if letter in LETTERS:
   letter_count[letter] += 1

 return letter_count




def    __UpperCamelCase     (				lowerCAmelCase__							:				tuple  ):
 return x[0]




def    __UpperCamelCase     (				lowerCAmelCase__							:				str  ):
 __a :  Optional[Any]						=  get_letter_count(lowerCAmelCase__  )
 __a :  dict[int, list[str]]						=  {
     freq: [] for letter, freq in letter_to_freq.items()
 }
 for letter in LETTERS:
  freq_to_letter[letter_to_freq[letter]].append(lowerCAmelCase__  )

 __a :  dict[int, str]						=  {}

 for freq in freq_to_letter:
  freq_to_letter[freq].sort(key=ETAOIN.find  ,   reverse=lowerCAmelCase__  )
  __a :  int						=  ''''''.join(freq_to_letter[freq]  )

 __a :  Any						=  list(freq_to_letter_str.items()  )
 freq_pairs.sort(key=lowerCAmelCase__  ,   reverse=lowerCAmelCase__  )

 __a :  list[str]						=  [freq_pair[1] for freq_pair in freq_pairs]

 return "".join(lowerCAmelCase__  )




def    __UpperCamelCase     (				lowerCAmelCase__							:				str  ):
 __a :  int						=  get_frequency_order(lowerCAmelCase__  )
 __a :  str						=  0
 for common_letter in ETAOIN[:6]:
  if common_letter in freq_order[:6]:
   match_score += 1

 for uncommon_letter in ETAOIN[-6:]:
  if uncommon_letter in freq_order[-6:]:
   match_score += 1

 return match_score


if __name__ == "__main__":
      import doctest

      doctest.testmod()
