






"""simple docstring"""


from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
       import tensorflow as tf

       from transformers import (
           TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
           TFTransfoXLForSequenceClassification,
           TFTransfoXLLMHeadModel,
           TFTransfoXLModel,
       )


class 					snake_case		:


   '''simple docstring'''

   def __init__(	self :     List[Any],       _lowerCamelCase :     Optional[Any],       ):

     '''simple docstring'''
     __A									= parent
     __A									= 13
     __A									= 7
     __A									= 30
     __A									= self.seq_length + self.mem_len
     __A									= 15
     __A									= True
     __A									= True
     __A									= 99
     __A									= [10, 50, 80]
     __A									= 32
     __A									= 32
     __A									= 4
     __A									= 8
     __A									= 1_28
     __A									= 2
     __A									= 2
     __A									= None
     __A									= 1
     __A									= 0
     __A									= 3
     __A									= self.vocab_size - 1
     __A									= 0.01


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int]  ):

     '''simple docstring'''
     __A									= ids_tensor([self.batch_size, self.seq_length],       self.vocab_size  )
     __A									= ids_tensor([self.batch_size, self.seq_length],       self.vocab_size  )

     __A									= None
     if self.use_labels:
       __A									= ids_tensor([self.batch_size, self.seq_length],       self.vocab_size  )

     __A									= TransfoXLConfig(
         vocab_size=self.vocab_size,       mem_len=self.mem_len,       clamp_len=self.clamp_len,       cutoffs=self.cutoffs,       d_model=self.hidden_size,       d_embed=self.d_embed,       n_head=self.num_attention_heads,       d_head=self.d_head,       d_inner=self.d_inner,       div_val=self.div_val,       n_layer=self.num_hidden_layers,       eos_token_id=self.eos_token_id,       pad_token_id=self.vocab_size - 1,       init_range=self.init_range,       num_labels=self.num_labels,       )

     return (config, input_ids_a, input_ids_a, lm_labels)


   def 				_SCREAMING_SNAKE_CASE				(	self :     List[str]  ):

     '''simple docstring'''
     random.seed(self.seed  )
     tf.random.set_seed(self.seed  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int],       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     Dict,       _lowerCamelCase :     Optional[Any],       _lowerCamelCase :     Tuple  ):

     '''simple docstring'''
     __A									= TFTransfoXLModel(_lowerCamelCase  )

     __A			,    __A									= model(_lowerCamelCase  ).to_tuple()

     __A									= {'''input_ids''': input_ids_a, '''mems''': mems_a}

     __A			,    __A									= model(_lowerCamelCase  ).to_tuple()

     self.parent.assertEqual(hidden_states_a.shape,       (self.batch_size, self.seq_length, self.hidden_size)  )
     self.parent.assertEqual(hidden_states_a.shape,       (self.batch_size, self.seq_length, self.hidden_size)  )
     self.parent.assertListEqual(
         [mem.shape for mem in mems_a],       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers,       )
     self.parent.assertListEqual(
         [mem.shape for mem in mems_a],       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers,       )


   def 				_SCREAMING_SNAKE_CASE				(	self :     int,       _lowerCamelCase :     Tuple,       _lowerCamelCase :     Optional[int],       _lowerCamelCase :     int,       _lowerCamelCase :     Optional[Any]  ):

     '''simple docstring'''
     __A									= TFTransfoXLLMHeadModel(_lowerCamelCase  )

     __A			,    __A									= model(_lowerCamelCase  ).to_tuple()

     __A									= {'''input_ids''': input_ids_a, '''labels''': lm_labels}
     __A			,    __A									= model(_lowerCamelCase  ).to_tuple()

     __A			,    __A									= model([input_ids_a, mems_a]  ).to_tuple()

     __A									= {'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

     __A			,    __A									= model(_lowerCamelCase  ).to_tuple()

     self.parent.assertEqual(lm_logits_a.shape,       (self.batch_size, self.seq_length, self.vocab_size)  )
     self.parent.assertListEqual(
         [mem.shape for mem in mems_a],       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers,       )

     self.parent.assertEqual(lm_logits_a.shape,       (self.batch_size, self.seq_length, self.vocab_size)  )
     self.parent.assertListEqual(
         [mem.shape for mem in mems_a],       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers,       )


   def 				_SCREAMING_SNAKE_CASE				(	self :     Dict,       _lowerCamelCase :     Dict,       _lowerCamelCase :     str,       _lowerCamelCase :     Tuple,       _lowerCamelCase :     Union[str, Any]  ):

     '''simple docstring'''
     __A									= TFTransfoXLForSequenceClassification(_lowerCamelCase  )
     __A									= model(_lowerCamelCase  )
     self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.num_labels)  )






   def 				_SCREAMING_SNAKE_CASE				(	self :     int  ):

     '''simple docstring'''
     __A									= self.prepare_config_and_inputs()
     ((__A)			,    (__A)			,    (__A)			,    (__A))									= config_and_inputs
     __A									= {'''input_ids''': input_ids_a}
     return config, inputs_dict





@require_tf
class 					snake_case		(							_lowerCAmelCase   ,	_lowerCAmelCase   ,	unittest.TestCase						):


   '''simple docstring'''

   A_						:	str						 = (
       (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
   )
   A_						:	Optional[int]						 = () if is_tf_available() else ()
   A_						:	Optional[Any]						 = (
       {
           "feature-extraction": TFTransfoXLModel,
           "text-classification": TFTransfoXLForSequenceClassification,
           "text-generation": TFTransfoXLLMHeadModel,
           "zero-shot": TFTransfoXLForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
   A_						:	int						 = False
   A_						:	Optional[int]						 = False
   A_						:	Dict						 = False
   A_						:	str						 = False


   def 				_SCREAMING_SNAKE_CASE				(	self :     Tuple,       _lowerCamelCase :     str,       _lowerCamelCase :     List[Any],       _lowerCamelCase :     List[Any],       _lowerCamelCase :     List[Any],       _lowerCamelCase :     str  ):

     '''simple docstring'''
     if pipeline_test_casse_name == "TextGenerationPipelineTests":
       # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
       # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
       # tokenizer.
       return True

     return False


   def 				_SCREAMING_SNAKE_CASE				(	self :     Union[str, Any]  ):

     '''simple docstring'''
     __A									= TFTransfoXLModelTester(self  )
     __A									= ConfigTester(self,       config_class=_lowerCamelCase,       d_embed=37  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     Tuple  ):

     '''simple docstring'''
     self.config_tester.run_common_tests()


   def 				_SCREAMING_SNAKE_CASE				(	self :     int  ):

     '''simple docstring'''
     self.model_tester.set_seed()
     __A									= self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_transfo_xl_model(*_lowerCamelCase  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int]  ):

     '''simple docstring'''
     self.model_tester.set_seed()
     __A									= self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_transfo_xl_lm_head(*_lowerCamelCase  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     Any  ):

     '''simple docstring'''
     __A									= self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*_lowerCamelCase  )


   def 				_SCREAMING_SNAKE_CASE				(	self :     Optional[int]  ):

     '''simple docstring'''
     __A			,    __A									= self.model_tester.prepare_config_and_inputs_for_common()
     __A									= [TFTransfoXLForSequenceClassification]

     for model_class in self.all_model_classes:
       __A									= model_class(_lowerCamelCase  )
       assert isinstance(model.get_input_embeddings(),       tf.keras.layers.Layer  )
       if model_class in list_other_models_with_output_ebd:
         __A									= model.get_output_embeddings()
         assert isinstance(_lowerCamelCase,       tf.keras.layers.Layer  )
         __A									= model.get_bias()
         assert name is None
       else:
         __A									= model.get_output_embeddings()
         assert x is None
         __A									= model.get_bias()
         assert name is None


   def 				_SCREAMING_SNAKE_CASE				(	self :     Dict  ):

     '''simple docstring'''
     # TODO JP: Make TransfoXL XLA compliant
     pass


   @slow
   def 				_SCREAMING_SNAKE_CASE				(	self :     Union[str, Any]  ):

     '''simple docstring'''
     for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __A									= TFTransfoXLModel.from_pretrained(_lowerCamelCase  )
       self.assertIsNotNone(_lowerCamelCase  )






   @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''  )
   def 				_SCREAMING_SNAKE_CASE				(	self :     Dict  ):

     '''simple docstring'''
     pass





@require_tf
class 					snake_case		(							unittest.TestCase						):


   '''simple docstring'''

   @unittest.skip('''Skip test until #12651 is resolved.'''  )
   @slow
   def 				_SCREAMING_SNAKE_CASE				(	self :     Dict  ):

     '''simple docstring'''
     __A									= TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''  )
     # fmt: off
     __A									= tf.convert_to_tensor([[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0]],       dtype=tf.intaa  )  # noqa: E231
     # fmt: on
     #  In 1991 , the remains of Russian Tsar Nicholas II and his family
     #  ( except for Alexei and Maria ) are discovered .
     #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
     #  remainder of the story . 1883 Western Siberia ,
     #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
     #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
     #  father initially slaps him for making such an accusation , Rasputin watches as the
     #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
     #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
     #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

     # fmt: off
     __A									= [33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0,33,1,18_57,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,28,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,0]  # noqa: E231
     # fmt: on
     #  In 1991, the remains of Russian Tsar Nicholas II and his family (
     #  except for Alexei and Maria ) are discovered. The voice of young son,
     #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
     #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
     #  and a group of men to perform magic. Rasputin has a vision and
     #  denounces one of the men as a horse thief. Although his father initially
     #  slaps him for making such an accusation, Rasputin watches as the man
     #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
     #  of the Virgin Mary, prompting him to become a priest.
     #  Rasputin quickly becomes famous, with people, even a bishop, begging for
     #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
     # Nicholas II and his family were discovered. The voice of <unk> young son,
     # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

     __A									= model.generate(_lowerCamelCase,       max_length=2_00,       do_sample=_lowerCamelCase  )
     self.assertListEqual(output_ids[0].numpy().tolist(),       _lowerCamelCase  )












"""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_				     =     '\\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_				     =     '\\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_				     =     '\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 				_SCREAMING_SNAKE_CASE				(	self :     Any  ):

     '''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 				_SCREAMING_SNAKE_CASE				(	self :     int,       _lowerCamelCase :     str,       _lowerCamelCase :     Optional[Any],       _lowerCamelCase :     Any=None,       _lowerCamelCase :     Tuple=None,       _lowerCamelCase :     Optional[Any]=None,       _lowerCamelCase :     Union[str, Any]=None,       _lowerCamelCase :     str="auto",       _lowerCamelCase :     Union[str, Any]=-1,       _lowerCamelCase :     List[str]=0.9,       _lowerCamelCase :     int=5,       _lowerCamelCase :     Tuple=5_00,       _lowerCamelCase :     Union[str, Any]="gpt2-large",       _lowerCamelCase :     int=-1,       _lowerCamelCase :     Union[str, Any]=10_24,       _lowerCamelCase :     Union[str, Any]=25,       _lowerCamelCase :     str=5,       _lowerCamelCase :     Any=True,       _lowerCamelCase :     Union[str, Any]=25,       ):

     '''simple docstring'''
     __A									= 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




