"""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		:

      def __init__(		self						,			__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      parent
            lowercase								=      13
            lowercase								=      7
            lowercase								=      True
            lowercase								=      True
            lowercase								=      True
            lowercase								=      True
            lowercase								=      True
            lowercase								=      False
            lowercase								=      False
            lowercase								=      False
            lowercase								=      2
            lowercase								=      99
            lowercase								=      0
            lowercase								=      32
            lowercase								=      2
            lowercase								=      4
            lowercase								=      0.1
            lowercase								=      0.1
            lowercase								=      512
            lowercase								=      16
            lowercase								=      2
            lowercase								=      0.0_2
            lowercase								=      3
            lowercase								=      4
            lowercase								=      """last"""
            lowercase								=      True
            lowercase								=      None
            lowercase								=      0

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      ids_tensor([self.batch_size, self.seq_length]						,			self.vocab_size		)
            lowercase								=      random_attention_mask([self.batch_size, self.seq_length]						,			dtype=tf.floataa		)

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

            lowercase								=      None
            if self.use_token_type_ids:
                  lowercase								=      ids_tensor([self.batch_size, self.seq_length]						,			self.n_langs		)

            lowercase								=      None
            lowercase								=      None
            lowercase								=      None
            if self.use_labels:
                  lowercase								=      ids_tensor([self.batch_size]						,			self.type_sequence_label_size		)
                  lowercase								=      ids_tensor([self.batch_size, self.seq_length]						,			self.num_labels		)
                  lowercase								=      ids_tensor([self.batch_size]						,			2						,			dtype=tf.floataa		)
                  lowercase								=      ids_tensor([self.batch_size]						,			self.num_choices		)

            lowercase								=      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 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      TFFlaubertModel(config=__lowerCAmelCase		)
            lowercase								=      {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
            lowercase								=      model(__lowerCAmelCase		)

            lowercase								=      [input_ids, input_mask]
            lowercase								=      model(__lowerCAmelCase		)
            self.parent.assertEqual(result.last_hidden_state.shape						,			(self.batch_size, self.seq_length, self.hidden_size)		)

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      TFFlaubertWithLMHeadModel(__lowerCAmelCase		)

            lowercase								=      {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
            lowercase								=      model(__lowerCAmelCase		)

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

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      TFFlaubertForQuestionAnsweringSimple(__lowerCAmelCase		)

            lowercase								=      {"""input_ids""": input_ids, """lengths""": input_lengths}

            lowercase								=      model(__lowerCAmelCase		)

            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						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      TFFlaubertForSequenceClassification(__lowerCAmelCase		)

            lowercase								=      {"""input_ids""": input_ids, """lengths""": input_lengths}

            lowercase								=      model(__lowerCAmelCase		)

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

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      self.num_labels
            lowercase								=      TFFlaubertForTokenClassification(config=__lowerCAmelCase		)
            lowercase								=      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
            lowercase								=      model(__lowerCAmelCase		)
            self.parent.assertEqual(result.logits.shape						,			(self.batch_size, self.seq_length, self.num_labels)		)

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			):







            """simple docstring"""



            lowercase								=      self.num_choices
            lowercase								=      TFFlaubertForMultipleChoice(config=__lowerCAmelCase		)
            lowercase								=      tf.tile(tf.expand_dims(__lowerCAmelCase						,			1		)						,			(1, self.num_choices, 1)		)
            lowercase								=      tf.tile(tf.expand_dims(__lowerCAmelCase						,			1		)						,			(1, self.num_choices, 1)		)
            lowercase								=      tf.tile(tf.expand_dims(__lowerCAmelCase						,			1		)						,			(1, self.num_choices, 1)		)
            lowercase								=      {
                """input_ids""": multiple_choice_inputs_ids,
                """attention_mask""": multiple_choice_input_mask,
                """token_type_ids""": multiple_choice_token_type_ids,
            }
            lowercase								=      model(__lowerCAmelCase		)
            self.parent.assertEqual(result.logits.shape						,			(self.batch_size, self.num_choices)		)







      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.prepare_config_and_inputs()
            (
                (
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				(
                lowercase
            )				,				
            )								=      config_and_inputs
            lowercase								=      {
                """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		(			lowerCAmelCase    ,       lowerCAmelCase    ,       unittest.TestCase      ):
      snake_case__     :  Optional[Any]				    =      (
          (
              TFFlaubertModel,
              TFFlaubertWithLMHeadModel,
              TFFlaubertForSequenceClassification,
              TFFlaubertForQuestionAnsweringSimple,
              TFFlaubertForTokenClassification,
              TFFlaubertForMultipleChoice,
          )
          if is_tf_available()
          else ()
      )
      snake_case__     :  Any				    =      (
          (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
      )  # TODO (PVP): Check other models whether language generation is also applicable
      snake_case__     :  Optional[Any]				    =      (
          {
              'feature-extraction': TFFlaubertModel,
              'fill-mask': TFFlaubertWithLMHeadModel,
              'question-answering': TFFlaubertForQuestionAnsweringSimple,
              'text-classification': TFFlaubertForSequenceClassification,
              'token-classification': TFFlaubertForTokenClassification,
              'zero-shot': TFFlaubertForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      snake_case__     :  Optional[int]				    =      False
      snake_case__     :  List[str]				    =      False

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		):







            """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 							A__			(		self		):







            """simple docstring"""



            lowercase								=      TFFlaubertModelTester(self		)
            lowercase								=      ConfigTester(self						,			config_class=__lowerCAmelCase						,			emb_dim=37		)

      def 							A__			(		self		):







            """simple docstring"""



            self.config_tester.run_common_tests()

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_model(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_lm_head(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_qa(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_sequence_classif(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_for_token_classification(*__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_flaubert_for_multiple_choice(*__lowerCAmelCase		)







      @slow
      def 							A__			(		self		):







            """simple docstring"""



            for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowercase								=      TFFlaubertModel.from_pretrained(__lowerCAmelCase		)
                  self.assertIsNotNone(__lowerCAmelCase		)






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

      @slow
      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased"""		)

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

            lowercase								=      model(__lowerCAmelCase		)[0]
            lowercase								=      tf.TensorShape((1, 8, 512)		)
            self.assertEqual(output.shape						,			__lowerCAmelCase		)
            # compare the actual values for a slice.
            lowercase								=      tf.convert_to_tensor(
                [
                    [
                        [-1.8_7_6_8_7_7_3, -1.5_6_6_5_5_5, 0.2_7_0_7_2_4_1_8],
                        [-1.6_9_2_0_0_3_8, -0.5_8_7_3_5_0_5, 1.9_3_2_9_5_9_9],
                        [-2.9_5_6_3_9_8_5, -1.6_9_9_3_8_3_5, 1.7_9_7_2_0_5_2],
                    ]
                ]						,			dtype=tf.floataa						,			)

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




"""simple docstring"""






from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCAmelCase       :			int   	=logging.get_logger(__name__)

__lowerCAmelCase       :			Optional[Any]   	={
    """uw-madison/mra-base-512-4""": """https://huggingface.co/uw-madison/mra-base-512-4/resolve/main/config.json""",
}





class 					_A		(			lowerCAmelCase      ):
      snake_case__     :  Optional[int]				    =      'mra'

      def __init__(		self						,			__lowerCAmelCase=5_0265						,			__lowerCAmelCase=768						,			__lowerCAmelCase=12						,			__lowerCAmelCase=12						,			__lowerCAmelCase=3072						,			__lowerCAmelCase="gelu"						,			__lowerCAmelCase=0.1						,			__lowerCAmelCase=0.1						,			__lowerCAmelCase=512						,			__lowerCAmelCase=1						,			__lowerCAmelCase=0.0_2						,			__lowerCAmelCase=1E-5						,			__lowerCAmelCase="absolute"						,			__lowerCAmelCase=4						,			__lowerCAmelCase="full"						,			__lowerCAmelCase=0						,			__lowerCAmelCase=0						,			__lowerCAmelCase=1						,			__lowerCAmelCase=0						,			__lowerCAmelCase=2						,			**__lowerCAmelCase						,			):







            """simple docstring"""



            super().__init__(pad_token_id=__lowerCAmelCase						,			bos_token_id=__lowerCAmelCase						,			eos_token_id=__lowerCAmelCase						,			**__lowerCAmelCase		)

            lowercase								=      vocab_size
            lowercase								=      max_position_embeddings
            lowercase								=      hidden_size
            lowercase								=      num_hidden_layers
            lowercase								=      num_attention_heads
            lowercase								=      intermediate_size
            lowercase								=      hidden_act
            lowercase								=      hidden_dropout_prob
            lowercase								=      attention_probs_dropout_prob
            lowercase								=      initializer_range
            lowercase								=      type_vocab_size
            lowercase								=      layer_norm_eps
            lowercase								=      position_embedding_type
            lowercase								=      block_per_row
            lowercase								=      approx_mode
            lowercase								=      initial_prior_first_n_blocks
            lowercase								=      initial_prior_diagonal_n_blocks



