
"""simple docstring"""





from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, 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 numpy as np
    import tensorflow as tf

    from transformers import (
        TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        FlaubertConfig,
        TFFlaubertForMultipleChoice,
        TFFlaubertForQuestionAnsweringSimple,
        TFFlaubertForSequenceClassification,
        TFFlaubertForTokenClassification,
        TFFlaubertModel,
        TFFlaubertWithLMHeadModel,
    )


class A_	:




  '''simple docstring'''







  def __init__(		self				,   lowercase_				,   ):

     """simple docstring"""
     UpperCAmelCase_					:					int			     =    parent
     UpperCAmelCase_					:					Tuple			     =    13
     UpperCAmelCase_					:					Dict			     =    7
     UpperCAmelCase_					:					Tuple			     =    True
     UpperCAmelCase_					:					Optional[Any]			     =    True
     UpperCAmelCase_					:					Optional[Any]			     =    True
     UpperCAmelCase_					:					Optional[int]			     =    True
     UpperCAmelCase_					:					Optional[Any]			     =    True
     UpperCAmelCase_					:					List[Any]			     =    False
     UpperCAmelCase_					:					Dict			     =    False
     UpperCAmelCase_					:					Optional[int]			     =    False
     UpperCAmelCase_					:					List[Any]			     =    2
     UpperCAmelCase_					:					Optional[Any]			     =    99
     UpperCAmelCase_					:					int			     =    0
     UpperCAmelCase_					:					int			     =    32
     UpperCAmelCase_					:					Optional[int]			     =    2
     UpperCAmelCase_					:					Any			     =    4
     UpperCAmelCase_					:					List[Any]			     =    0.1
     UpperCAmelCase_					:					Optional[int]			     =    0.1
     UpperCAmelCase_					:					Tuple			     =    512
     UpperCAmelCase_					:					int			     =    16
     UpperCAmelCase_					:					Tuple			     =    2
     UpperCAmelCase_					:					Union[str, Any]			     =    0.02
     UpperCAmelCase_					:					Optional[int]			     =    3
     UpperCAmelCase_					:					Any			     =    4
     UpperCAmelCase_					:					List[str]			     =    "last"
     UpperCAmelCase_					:					Optional[Any]			     =    True
     UpperCAmelCase_					:					Optional[Any]			     =    None
     UpperCAmelCase_					:					Union[str, Any]			     =    0







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    ids_tensor([self.batch_size, self.seq_length]				,   self.vocab_size  )
     UpperCAmelCase_					:					Optional[Any]			     =    random_attention_mask([self.batch_size, self.seq_length]				,   dtype=tf.floataa  )

     UpperCAmelCase_					:					Optional[int]			     =    None
     if self.use_input_lengths:
        UpperCAmelCase_					:					Dict			     =    (
            ids_tensor([self.batch_size]				,   vocab_size=2  ) + self.seq_length - 2
        )  # small variation of seq_length

     UpperCAmelCase_					:					List[Any]			     =    None
     if self.use_token_type_ids:
        UpperCAmelCase_					:					Union[str, Any]			     =    ids_tensor([self.batch_size, self.seq_length]				,   self.n_langs  )

     UpperCAmelCase_					:					List[str]			     =    None
     UpperCAmelCase_					:					Tuple			     =    None
     UpperCAmelCase_					:					Union[str, Any]			     =    None
     if self.use_labels:
        UpperCAmelCase_					:					Optional[int]			     =    ids_tensor([self.batch_size]				,   self.type_sequence_label_size  )
        UpperCAmelCase_					:					Dict			     =    ids_tensor([self.batch_size, self.seq_length]				,   self.num_labels  )
        UpperCAmelCase_					:					List[str]			     =    ids_tensor([self.batch_size]				,   2				,   dtype=tf.floataa  )
        UpperCAmelCase_					:					Optional[int]			     =    ids_tensor([self.batch_size]				,   self.num_choices  )

     UpperCAmelCase_					:					int			     =    FlaubertConfig(
         vocab_size=self.vocab_size				,   n_special=self.n_special				,   emb_dim=self.hidden_size				,   n_layers=self.num_hidden_layers				,   n_heads=self.num_attention_heads				,   dropout=self.hidden_dropout_prob				,   attention_dropout=self.attention_probs_dropout_prob				,   gelu_activation=self.gelu_activation				,   sinusoidal_embeddings=self.sinusoidal_embeddings				,   asm=self.asm				,   causal=self.causal				,   n_langs=self.n_langs				,   max_position_embeddings=self.max_position_embeddings				,   initializer_range=self.initializer_range				,   summary_type=self.summary_type				,   use_proj=self.use_proj				,   bos_token_id=self.bos_token_id				,   )

     return (
         config,
         input_ids,
         token_type_ids,
         input_lengths,
         sequence_labels,
         token_labels,
         is_impossible_labels,
         choice_labels,
         input_mask,
     )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    TFFlaubertModel(config=lowercase_  )
     UpperCAmelCase_					:					str			     =    {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
     UpperCAmelCase_					:					Any			     =    model(lowercase_  )

     UpperCAmelCase_					:					List[str]			     =    [input_ids, input_mask]
     UpperCAmelCase_					:					Optional[Any]			     =    model(lowercase_  )
     self.parent.assertEqual(result.last_hidden_state.shape				,   (self.batch_size, self.seq_length, self.hidden_size)  )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    TFFlaubertWithLMHeadModel(lowercase_  )

     UpperCAmelCase_					:					Dict			     =    {"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
     UpperCAmelCase_					:					int			     =    model(lowercase_  )

     self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.seq_length, self.vocab_size)  )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   ):

     """simple docstring"""
     UpperCAmelCase_					:					Union[str, Any]			     =    TFFlaubertForQuestionAnsweringSimple(lowercase_  )

     UpperCAmelCase_					:					List[Any]			     =    {"input_ids": input_ids, "lengths": input_lengths}

     UpperCAmelCase_					:					Tuple			     =    model(lowercase_  )

     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        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    TFFlaubertForSequenceClassification(lowercase_  )

     UpperCAmelCase_					:					Tuple			     =    {"input_ids": input_ids, "lengths": input_lengths}

     UpperCAmelCase_					:					Dict			     =    model(lowercase_  )

     self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.type_sequence_label_size)  )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    self.num_labels
     UpperCAmelCase_					:					int			     =    TFFlaubertForTokenClassification(config=lowercase_  )
     UpperCAmelCase_					:					Any			     =    {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
     UpperCAmelCase_					:					Any			     =    model(lowercase_  )
     self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.seq_length, self.num_labels)  )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[int]			     =    self.num_choices
     UpperCAmelCase_					:					int			     =    TFFlaubertForMultipleChoice(config=lowercase_  )
     UpperCAmelCase_					:					List[str]			     =    tf.tile(tf.expand_dims(lowercase_				,   1  )				,   (1, self.num_choices, 1)  )
     UpperCAmelCase_					:					int			     =    tf.tile(tf.expand_dims(lowercase_				,   1  )				,   (1, self.num_choices, 1)  )
     UpperCAmelCase_					:					Any			     =    tf.tile(tf.expand_dims(lowercase_				,   1  )				,   (1, self.num_choices, 1)  )
     UpperCAmelCase_					:					Optional[int]			     =    {
         "input_ids": multiple_choice_inputs_ids,
         "attention_mask": multiple_choice_input_mask,
         "token_type_ids": multiple_choice_token_type_ids,
     }
     UpperCAmelCase_					:					List[str]			     =    model(lowercase_  )
     self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.num_choices)  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					str			     =    self.prepare_config_and_inputs()
     (
         (
         UpperCAmelCase_
     )     ,   (
         UpperCAmelCase_
     )     ,   (
         UpperCAmelCase_
     )     ,   (
         UpperCAmelCase_
     )     ,   (
         UpperCAmelCase_
     )     ,   (
         UpperCAmelCase_
     )     ,   (
         UpperCAmelCase_
     )     ,   (
         UpperCAmelCase_
     )     ,   (
         UpperCAmelCase_
     )     ,   
     )					:					List[Any]			     =    config_and_inputs
     UpperCAmelCase_					:					List[str]			     =    {
         "input_ids": input_ids,
         "token_type_ids": token_type_ids,
         "langs": token_type_ids,
         "lengths": input_lengths,
     }
     return config, inputs_dict




@require_tf
class A_	(lowercase__				,lowercase__				,unittest.TestCase      ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__			:						List[Any]       =		(
      (
          TFFlaubertModel,
          TFFlaubertWithLMHeadModel,
          TFFlaubertForSequenceClassification,
          TFFlaubertForQuestionAnsweringSimple,
          TFFlaubertForTokenClassification,
          TFFlaubertForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  SCREAMING_SNAKE_CASE__			:						Optional[int]       =		(
      (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
  )  # TODO (PVP): Check other models whether language generation is also applicable
  SCREAMING_SNAKE_CASE__			:						List[str]       =		(
      {
          """feature-extraction""": TFFlaubertModel,
          """fill-mask""": TFFlaubertWithLMHeadModel,
          """question-answering""": TFFlaubertForQuestionAnsweringSimple,
          """text-classification""": TFFlaubertForSequenceClassification,
          """token-classification""": TFFlaubertForTokenClassification,
          """zero-shot""": TFFlaubertForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  SCREAMING_SNAKE_CASE__			:						Optional[Any]       =		False
  SCREAMING_SNAKE_CASE__			:						Union[str, Any]       =		False







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     if (
         pipeline_test_casse_name == "QAPipelineTests"
         and tokenizer_name is not None
         and not tokenizer_name.endswith("Fast"  )
     ):
        # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
        # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
        # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
        return True

     return False







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Dict			     =    TFFlaubertModelTester(self  )
     UpperCAmelCase_					:					Any			     =    ConfigTester(self				,   config_class=lowercase_				,   emb_dim=37  )







  def        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Union[str, Any]			     =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_model(*lowercase_  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					int			     =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_lm_head(*lowercase_  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					str			     =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_qa(*lowercase_  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[str]			     =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_sequence_classif(*lowercase_  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Dict			     =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_for_token_classification(*lowercase_  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[str]			     =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_for_multiple_choice(*lowercase_  )







  @slow
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        UpperCAmelCase_					:					Optional[Any]			     =    TFFlaubertModel.from_pretrained(lowercase_  )
        self.assertIsNotNone(lowercase_  )




@require_tf
@require_sentencepiece
@require_tokenizers
class A_	(unittest.TestCase      ):




  '''simple docstring'''







  @slow
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					str			     =    TFFlaubertModel.from_pretrained("jplu/tf-flaubert-small-cased"  )

     UpperCAmelCase_					:					Dict			     =    tf.convert_to_tensor(
         [[0, 158, 735, 2592, 1424, 6727, 82, 1]]				,   dtype=tf.intaa				,   )  # "J'aime flaubert !"

     UpperCAmelCase_					:					Optional[Any]			     =    model(lowercase_  )[0]
     UpperCAmelCase_					:					Dict			     =    tf.TensorShape((1, 8, 512)  )
     self.assertEqual(output.shape				,   lowercase_  )
     # compare the actual values for a slice.
     UpperCAmelCase_					:					int			     =    tf.convert_to_tensor(
         [
             [
                 [-1.8_76_87_73, -1.56_65_55, 0.27_07_24_18],
                 [-1.6_92_00_38, -0.5_87_35_05, 1.9_32_95_99],
                 [-2.9_56_39_85, -1.6_99_38_35, 1.7_97_20_52],
             ]
         ]				,   dtype=tf.floataa				,   )

     self.assertTrue(np.allclose(output[:, :3, :3].numpy()				,   expected_slice.numpy()				,   atol=1E-4  )  )




"""simple docstring"""





from ...utils import is_torch_available, is_transformers_available


if is_transformers_available() and is_torch_available():
    from .pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings, VQDiffusionPipeline


