






'''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 UpperCAmelCase_					(    datasets.Metric				):




      """simple docstring"""




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


       '''simple docstring'''

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











'''simple docstring'''



from __future__ import annotations

import unittest

from transformers import DistilBertConfig, 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, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
      import tensorflow as tf

      from transformers.models.distilbert.modeling_tf_distilbert import (
          TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFDistilBertForMaskedLM,
          TFDistilBertForMultipleChoice,
          TFDistilBertForQuestionAnswering,
          TFDistilBertForSequenceClassification,
          TFDistilBertForTokenClassification,
          TFDistilBertModel,
      )
class UpperCAmelCase_					:




      """simple docstring"""




      def __init__( self			:		Tuple     ,      UpperCAmelCase			:		List[str]     ,      )  ->  Union[str, Any]:


       '''simple docstring'''

       lowercase					:   int				  =parent
       lowercase					:   Any				  =13
       lowercase					:   Any				  =7
       lowercase					:   Optional[int]				  =True
       lowercase					:   Optional[int]				  =True
       lowercase					:   Tuple				  =False
       lowercase					:   Optional[Any]				  =True
       lowercase					:   Dict				  =99
       lowercase					:   Union[str, Any]				  =32
       lowercase					:   Union[str, Any]				  =2
       lowercase					:   Union[str, Any]				  =4
       lowercase					:   List[str]				  =37
       lowercase					:   str				  ='''gelu'''
       lowercase					:   Dict				  =0.1
       lowercase					:   List[Any]				  =0.1
       lowercase					:   List[str]				  =512
       lowercase					:   Optional[int]				  =16
       lowercase					:   Optional[Any]				  =2
       lowercase					:   List[str]				  =0.0_2
       lowercase					:   Any				  =3
       lowercase					:   Optional[Any]				  =4
       lowercase					:   int				  =None






      def 				A__      ( self			:		List[str]		)  ->  Dict:


       '''simple docstring'''

       lowercase					:   Tuple				  =ids_tensor([self.batch_size, self.seq_length]     ,      self.vocab_size		)

       lowercase					:   Any				  =None
       if self.use_input_mask:
        lowercase					:   List[str]				  =random_attention_mask([self.batch_size, self.seq_length]		)

       lowercase					:   Union[str, Any]				  =None
       lowercase					:   Any				  =None
       lowercase					:   str				  =None
       if self.use_labels:
        lowercase					:   Union[str, Any]				  =ids_tensor([self.batch_size]     ,      self.type_sequence_label_size		)
        lowercase					:   Tuple				  =ids_tensor([self.batch_size, self.seq_length]     ,      self.num_labels		)
        lowercase					:   List[Any]				  =ids_tensor([self.batch_size]     ,      self.num_choices		)

       lowercase					:   Dict				  =DistilBertConfig(
           vocab_size=self.vocab_size     ,      dim=self.hidden_size     ,      n_layers=self.num_hidden_layers     ,      n_heads=self.num_attention_heads     ,      hidden_dim=self.intermediate_size     ,      hidden_act=self.hidden_act     ,      dropout=self.hidden_dropout_prob     ,      attention_dropout=self.attention_probs_dropout_prob     ,      max_position_embeddings=self.max_position_embeddings     ,      initializer_range=self.initializer_range     ,      )

       return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels






      def 				A__      ( self			:		Any     ,      UpperCAmelCase			:		Dict     ,      UpperCAmelCase			:		List[str]     ,      UpperCAmelCase			:		Any     ,      UpperCAmelCase			:		List[str]     ,      UpperCAmelCase			:		Dict     ,      UpperCAmelCase			:		Optional[Any]		)  ->  Union[str, Any]:


       '''simple docstring'''

       lowercase					:   int				  =TFDistilBertModel(config=UpperCAmelCase		)
       lowercase					:   int				  ={'''input_ids''': input_ids, '''attention_mask''': input_mask}

       lowercase					:   List[str]				  =model(UpperCAmelCase		)

       lowercase					:   str				  =[input_ids, input_mask]

       lowercase					:   Tuple				  =model(UpperCAmelCase		)

       self.parent.assertEqual(result.last_hidden_state.shape     ,      (self.batch_size, self.seq_length, self.hidden_size)		)






      def 				A__      ( self			:		List[Any]     ,      UpperCAmelCase			:		Any     ,      UpperCAmelCase			:		int     ,      UpperCAmelCase			:		Dict     ,      UpperCAmelCase			:		List[str]     ,      UpperCAmelCase			:		List[str]     ,      UpperCAmelCase			:		Optional[Any]		)  ->  Tuple:


       '''simple docstring'''

       lowercase					:   List[str]				  =TFDistilBertForMaskedLM(config=UpperCAmelCase		)
       lowercase					:   int				  ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
       lowercase					:   Union[str, Any]				  =model(UpperCAmelCase		)
       self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.seq_length, self.vocab_size)		)






      def 				A__      ( self			:		List[Any]     ,      UpperCAmelCase			:		int     ,      UpperCAmelCase			:		Union[str, Any]     ,      UpperCAmelCase			:		Union[str, Any]     ,      UpperCAmelCase			:		Union[str, Any]     ,      UpperCAmelCase			:		List[Any]     ,      UpperCAmelCase			:		Optional[int]		)  ->  Any:


       '''simple docstring'''

       lowercase					:   str				  =TFDistilBertForQuestionAnswering(config=UpperCAmelCase		)
       lowercase					:   int				  ={
           '''input_ids''': input_ids,
           '''attention_mask''': input_mask,
       }
       lowercase					:   List[str]				  =model(UpperCAmelCase		)
       self.parent.assertEqual(result.start_logits.shape     ,      (self.batch_size, self.seq_length)		)
       self.parent.assertEqual(result.end_logits.shape     ,      (self.batch_size, self.seq_length)		)






      def 				A__      ( self			:		str     ,      UpperCAmelCase			:		int     ,      UpperCAmelCase			:		List[str]     ,      UpperCAmelCase			:		List[Any]     ,      UpperCAmelCase			:		Tuple     ,      UpperCAmelCase			:		Optional[Any]     ,      UpperCAmelCase			:		Dict		)  ->  Optional[int]:


       '''simple docstring'''

       lowercase					:   Dict				  =self.num_labels
       lowercase					:   Optional[Any]				  =TFDistilBertForSequenceClassification(UpperCAmelCase		)
       lowercase					:   str				  ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
       lowercase					:   Union[str, Any]				  =model(UpperCAmelCase		)
       self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.num_labels)		)






      def 				A__      ( self			:		int     ,      UpperCAmelCase			:		str     ,      UpperCAmelCase			:		str     ,      UpperCAmelCase			:		Any     ,      UpperCAmelCase			:		str     ,      UpperCAmelCase			:		int     ,      UpperCAmelCase			:		Dict		)  ->  List[str]:


       '''simple docstring'''

       lowercase					:   List[Any]				  =self.num_choices
       lowercase					:   Optional[int]				  =TFDistilBertForMultipleChoice(UpperCAmelCase		)
       lowercase					:   Optional[Any]				  =tf.tile(tf.expand_dims(UpperCAmelCase     ,      1		)     ,      (1, self.num_choices, 1)		)
       lowercase					:   List[Any]				  =tf.tile(tf.expand_dims(UpperCAmelCase     ,      1		)     ,      (1, self.num_choices, 1)		)
       lowercase					:   Tuple				  ={
           '''input_ids''': multiple_choice_inputs_ids,
           '''attention_mask''': multiple_choice_input_mask,
       }
       lowercase					:   Tuple				  =model(UpperCAmelCase		)
       self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.num_choices)		)






      def 				A__      ( self			:		List[Any]     ,      UpperCAmelCase			:		Optional[Any]     ,      UpperCAmelCase			:		Tuple     ,      UpperCAmelCase			:		Optional[Any]     ,      UpperCAmelCase			:		Dict     ,      UpperCAmelCase			:		List[Any]     ,      UpperCAmelCase			:		Union[str, Any]		)  ->  Dict:


       '''simple docstring'''

       lowercase					:   Dict				  =self.num_labels
       lowercase					:   Tuple				  =TFDistilBertForTokenClassification(UpperCAmelCase		)
       lowercase					:   Optional[Any]				  ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
       lowercase					:   str				  =model(UpperCAmelCase		)
       self.parent.assertEqual(result.logits.shape     ,      (self.batch_size, self.seq_length, self.num_labels)		)






      def 				A__      ( self			:		List[str]		)  ->  Dict:


       '''simple docstring'''

       lowercase					:   int				  =self.prepare_config_and_inputs()
       ((lowercase)  ,		(lowercase)  ,		(lowercase)  ,		(lowercase)  ,		(lowercase)  ,		(lowercase))					:   Union[str, Any]				  =config_and_inputs
       lowercase					:   Tuple				  ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
       return config, inputs_dict





@require_tf
class UpperCAmelCase_					(    __A				,       __A				,       unittest.TestCase				):




      """simple docstring"""




      UpperCamelCase_								=			(
          (
              TFDistilBertModel,
              TFDistilBertForMaskedLM,
              TFDistilBertForQuestionAnswering,
              TFDistilBertForSequenceClassification,
              TFDistilBertForTokenClassification,
              TFDistilBertForMultipleChoice,
          )
          if is_tf_available()
          else None
      )
      UpperCamelCase_								=			(
          {
              '''feature-extraction''': TFDistilBertModel,
              '''fill-mask''': TFDistilBertForMaskedLM,
              '''question-answering''': TFDistilBertForQuestionAnswering,
              '''text-classification''': TFDistilBertForSequenceClassification,
              '''token-classification''': TFDistilBertForTokenClassification,
              '''zero-shot''': TFDistilBertForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      UpperCamelCase_								=			False
      UpperCamelCase_								=			False






      def 				A__      ( self			:		Dict		)  ->  str:


       '''simple docstring'''

       lowercase					:   str				  =TFDistilBertModelTester(self		)
       lowercase					:   int				  =ConfigTester(self     ,      config_class=UpperCAmelCase     ,      dim=37		)






      def 				A__      ( self			:		Union[str, Any]		)  ->  Dict:


       '''simple docstring'''

       self.config_tester.run_common_tests()






      def 				A__      ( self			:		Optional[Any]		)  ->  Tuple:


       '''simple docstring'''

       lowercase					:   List[Any]				  =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_model(*UpperCAmelCase		)






      def 				A__      ( self			:		Tuple		)  ->  Any:


       '''simple docstring'''

       lowercase					:   str				  =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_for_masked_lm(*UpperCAmelCase		)






      def 				A__      ( self			:		Optional[int]		)  ->  List[Any]:


       '''simple docstring'''

       lowercase					:   Any				  =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_for_question_answering(*UpperCAmelCase		)






      def 				A__      ( self			:		Any		)  ->  str:


       '''simple docstring'''

       lowercase					:   List[Any]				  =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_for_sequence_classification(*UpperCAmelCase		)






      def 				A__      ( self			:		Optional[Any]		)  ->  List[str]:


       '''simple docstring'''

       lowercase					:   str				  =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_for_multiple_choice(*UpperCAmelCase		)






      def 				A__      ( self			:		str		)  ->  Union[str, Any]:


       '''simple docstring'''

       lowercase					:   str				  =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_distilbert_for_token_classification(*UpperCAmelCase		)






      @slow
      def 				A__      ( self			:		List[Any]		)  ->  Dict:


       '''simple docstring'''

       for model_name in list(TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]		):
        lowercase					:   Union[str, Any]				  =TFDistilBertModel.from_pretrained(UpperCAmelCase		)
        self.assertIsNotNone(UpperCAmelCase		)





@require_tf
class UpperCAmelCase_					(    unittest.TestCase				):




      """simple docstring"""




      @slow
      def 				A__      ( self			:		List[str]		)  ->  List[Any]:


       '''simple docstring'''

       lowercase					:   Optional[Any]				  =TFDistilBertModel.from_pretrained('''distilbert-base-uncased'''		)
       lowercase					:   Tuple				  =tf.constant([[0, 1, 2, 3, 4, 5]]		)
       lowercase					:   List[Any]				  =model(UpperCAmelCase		)[0]

       lowercase					:   str				  =[1, 6, 768]
       self.assertEqual(output.shape     ,      UpperCAmelCase		)

       lowercase					:   Optional[int]				  =tf.constant(
           [
               [
                   [0.1_9_2_6_1_8_8_5, -0.1_3_7_3_2_9_5_5, 0.4_1_1_9_7_9_9],
                   [0.2_2_1_5_0_1_5_6, -0.0_7_4_2_2_6_6_1, 0.3_9_0_3_7_2_0_4],
                   [0.2_2_7_5_6_0_1_8, -0.0_8_9_6_4_1_4, 0.3_7_0_1_4_6_7],
               ]
           ]		)
       tf.debugging.assert_near(output[:, :3, :3]     ,      UpperCAmelCase     ,      atol=1e-4		)



