





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


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

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

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




 def 				_snake_case (						self		)     ->				Union[str, 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 				_snake_case (						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      ,  )     ->				Optional[int]:
     _lowerCAmelCase						      =   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









'''simple docstring'''


import unittest
from queue import Empty
from threading import Thread

from transformers import AutoTokenizer, TextIteratorStreamer, TextStreamer, is_torch_available
from transformers.testing_utils import CaptureStdout, require_torch, torch_device

from ..test_modeling_common import ids_tensor


if is_torch_available():
       import torch

       from transformers import AutoModelForCausalLM

@require_torch
class  lowerCAmelCase_		(		unittest.TestCase		):




 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"		)
     _lowerCAmelCase						      =   AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"		).to(_lowerCAmelCase		)
     _lowerCAmelCase						      =   -1

     _lowerCAmelCase						      =   ids_tensor((1, 5)      ,  vocab_size=model.config.vocab_size		).to(_lowerCAmelCase		)
     _lowerCAmelCase						      =   model.generate(_lowerCAmelCase      ,  max_new_tokens=10      ,  do_sample=_lowerCAmelCase		)
     _lowerCAmelCase						      =   tokenizer.decode(greedy_ids[0]		)

     with CaptureStdout() as cs:
         _lowerCAmelCase						      =   TextStreamer(_lowerCAmelCase		)
         model.generate(_lowerCAmelCase      ,  max_new_tokens=10      ,  do_sample=_lowerCAmelCase      ,  streamer=_lowerCAmelCase		)
     # The greedy text should be printed to stdout, except for the final "\n" in the streamer
     _lowerCAmelCase						      =   cs.out[:-1]

     self.assertEqual(_lowerCAmelCase      ,  _lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"		)
     _lowerCAmelCase						      =   AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"		).to(_lowerCAmelCase		)
     _lowerCAmelCase						      =   -1

     _lowerCAmelCase						      =   ids_tensor((1, 5)      ,  vocab_size=model.config.vocab_size		).to(_lowerCAmelCase		)
     _lowerCAmelCase						      =   model.generate(_lowerCAmelCase      ,  max_new_tokens=10      ,  do_sample=_lowerCAmelCase		)
     _lowerCAmelCase						      =   tokenizer.decode(greedy_ids[0]		)

     _lowerCAmelCase						      =   TextIteratorStreamer(_lowerCAmelCase		)
     _lowerCAmelCase						      =   {"input_ids": input_ids, "max_new_tokens": 10, "do_sample": False, "streamer": streamer}
     _lowerCAmelCase						      =   Thread(target=model.generate      ,  kwargs=_lowerCAmelCase		)
     thread.start()
     _lowerCAmelCase						      =   ""
     for new_text in streamer:
         streamer_text += new_text

     self.assertEqual(_lowerCAmelCase      ,  _lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				List[str]:
     _lowerCAmelCase						      =   AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"		)
     _lowerCAmelCase						      =   AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"		).to(_lowerCAmelCase		)
     _lowerCAmelCase						      =   -1

     _lowerCAmelCase						      =   ids_tensor((1, 5)      ,  vocab_size=model.config.vocab_size		).to(_lowerCAmelCase		)
     _lowerCAmelCase						      =   model.generate(_lowerCAmelCase      ,  max_new_tokens=10      ,  do_sample=_lowerCAmelCase		)
     _lowerCAmelCase						      =   greedy_ids[:, input_ids.shape[1] :]
     _lowerCAmelCase						      =   tokenizer.decode(new_greedy_ids[0]		)

     with CaptureStdout() as cs:
         _lowerCAmelCase						      =   TextStreamer(_lowerCAmelCase      ,  skip_prompt=_lowerCAmelCase		)
         model.generate(_lowerCAmelCase      ,  max_new_tokens=10      ,  do_sample=_lowerCAmelCase      ,  streamer=_lowerCAmelCase		)
     # The greedy text should be printed to stdout, except for the final "\n" in the streamer
     _lowerCAmelCase						      =   cs.out[:-1]

     self.assertEqual(_lowerCAmelCase      ,  _lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Dict:
     # Tests that we can pass `decode_kwargs` to the streamer to control how the tokens are decoded. Must be tested
     # with actual models -- the dummy models' tokenizers are not aligned with their models, and
     # `skip_special_tokens=True` has no effect on them
     _lowerCAmelCase						      =   AutoTokenizer.from_pretrained("distilgpt2"		)
     _lowerCAmelCase						      =   AutoModelForCausalLM.from_pretrained("distilgpt2"		).to(_lowerCAmelCase		)
     _lowerCAmelCase						      =   -1

     _lowerCAmelCase						      =   torch.ones((1, 5)      ,  device=_lowerCAmelCase		).long() * model.config.bos_token_id
     with CaptureStdout() as cs:
         _lowerCAmelCase						      =   TextStreamer(_lowerCAmelCase      ,  skip_special_tokens=_lowerCAmelCase		)
         model.generate(_lowerCAmelCase      ,  max_new_tokens=1      ,  do_sample=_lowerCAmelCase      ,  streamer=_lowerCAmelCase		)

     # The prompt contains a special token, so the streamer should not print it. As such, the output text, when
     # re-tokenized, must only contain one token
     _lowerCAmelCase						      =   cs.out[:-1]  # Remove the final "\n"
     _lowerCAmelCase						      =   tokenizer(_lowerCAmelCase      ,  return_tensors="pt"		)
     self.assertEqual(streamer_text_tokenized.input_ids.shape      ,  (1, 1)		)





 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"		)
     _lowerCAmelCase						      =   AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"		).to(_lowerCAmelCase		)
     _lowerCAmelCase						      =   -1

     _lowerCAmelCase						      =   ids_tensor((1, 5)      ,  vocab_size=model.config.vocab_size		).to(_lowerCAmelCase		)
     _lowerCAmelCase						      =   TextIteratorStreamer(_lowerCAmelCase      ,  timeout=0.001		)
     _lowerCAmelCase						      =   {"input_ids": input_ids, "max_new_tokens": 10, "do_sample": False, "streamer": streamer}
     _lowerCAmelCase						      =   Thread(target=model.generate      ,  kwargs=_lowerCAmelCase		)
     thread.start()

     # The streamer will timeout after 0.001 seconds, so an exception will be raised
     with self.assertRaises(_lowerCAmelCase		):
         _lowerCAmelCase						      =   ""
         for new_text in streamer:
             streamer_text += new_text


