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







  '''simple docstring'''






  def __init__(			self				,		snake_case_				,		):




       '''simple docstring'''

       UpperCAmelCase_							:       Tuple       =				parent
       UpperCAmelCase_							:       str       =				1_3
       UpperCAmelCase_							:       List[str]       =				7
       UpperCAmelCase_							:       Union[str, Any]       =				True
       UpperCAmelCase_							:       Optional[int]       =				True
       UpperCAmelCase_							:       List[Any]       =				True
       UpperCAmelCase_							:       Any       =				True
       UpperCAmelCase_							:       Dict       =				True
       UpperCAmelCase_							:       Any       =				False
       UpperCAmelCase_							:       Tuple       =				False
       UpperCAmelCase_							:       int       =				False
       UpperCAmelCase_							:       Any       =				2
       UpperCAmelCase_							:       str       =				9_9
       UpperCAmelCase_							:       Tuple       =				0
       UpperCAmelCase_							:       Dict       =				3_2
       UpperCAmelCase_							:       int       =				2
       UpperCAmelCase_							:       Union[str, Any]       =				4
       UpperCAmelCase_							:       Tuple       =				0.1
       UpperCAmelCase_							:       Optional[int]       =				0.1
       UpperCAmelCase_							:       Optional[Any]       =				5_1_2
       UpperCAmelCase_							:       Optional[Any]       =				1_6
       UpperCAmelCase_							:       Union[str, Any]       =				2
       UpperCAmelCase_							:       Any       =				0.02
       UpperCAmelCase_							:       Dict       =				3
       UpperCAmelCase_							:       List[Any]       =				4
       UpperCAmelCase_							:       Union[str, Any]       =				'last'
       UpperCAmelCase_							:       Optional[Any]       =				True
       UpperCAmelCase_							:       Tuple       =				None
       UpperCAmelCase_							:       Optional[Any]       =				0


  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       UpperCAmelCase_							:       str       =				ids_tensor([self.batch_size, self.seq_length]				,		self.vocab_size						)
       UpperCAmelCase_							:       Optional[int]       =				random_attention_mask([self.batch_size, self.seq_length]				,		dtype=tf.floataa						)

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

       UpperCAmelCase_							:       str       =				None
       if self.use_token_type_ids:
            UpperCAmelCase_							:       Optional[int]       =				ids_tensor([self.batch_size, self.seq_length]				,		self.n_langs						)

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

       UpperCAmelCase_							:       str       =				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				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		):




       '''simple docstring'''

       UpperCAmelCase_							:       Tuple       =				TFFlaubertModel(config=snake_case_						)
       UpperCAmelCase_							:       str       =				{'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
       UpperCAmelCase_							:       Dict       =				model(snake_case_						)

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


  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		):




       '''simple docstring'''

       UpperCAmelCase_							:       Dict       =				TFFlaubertWithLMHeadModel(snake_case_						)

       UpperCAmelCase_							:       Tuple       =				{'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
       UpperCAmelCase_							:       Tuple       =				model(snake_case_						)

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


  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		):




       '''simple docstring'''

       UpperCAmelCase_							:       Optional[int]       =				TFFlaubertForQuestionAnsweringSimple(snake_case_						)

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

       UpperCAmelCase_							:       Union[str, Any]       =				model(snake_case_						)

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




       '''simple docstring'''

       UpperCAmelCase_							:       List[Any]       =				TFFlaubertForSequenceClassification(snake_case_						)

       UpperCAmelCase_							:       Optional[int]       =				{'input_ids': input_ids, 'lengths': input_lengths}

       UpperCAmelCase_							:       Union[str, Any]       =				model(snake_case_						)

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


  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		):




       '''simple docstring'''

       UpperCAmelCase_							:       int       =				self.num_labels
       UpperCAmelCase_							:       int       =				TFFlaubertForTokenClassification(config=snake_case_						)
       UpperCAmelCase_							:       List[str]       =				{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
       UpperCAmelCase_							:       int       =				model(snake_case_						)
       self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.seq_length, self.num_labels)						)


  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		):




       '''simple docstring'''

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






  def _UpperCamelCase					(			self						):




       '''simple docstring'''

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







@require_tf
class 					__SCREAMING_SNAKE_CASE						(	lowerCamelCase_						,     lowerCamelCase_						,     unittest.TestCase	):







  '''simple docstring'''






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


  def _UpperCamelCase					(			self				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_				,		snake_case_						):




       '''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_							:       List[str]       =				TFFlaubertModelTester(self						)
       UpperCAmelCase_							:       Union[str, Any]       =				ConfigTester(self				,		config_class=snake_case_				,		emb_dim=3_7						)


  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       self.config_tester.run_common_tests()


  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       UpperCAmelCase_							:       Tuple       =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_model(*snake_case_						)


  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       UpperCAmelCase_							:       Union[str, Any]       =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_lm_head(*snake_case_						)


  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       UpperCAmelCase_							:       Union[str, Any]       =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_qa(*snake_case_						)


  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       UpperCAmelCase_							:       List[str]       =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_sequence_classif(*snake_case_						)


  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       UpperCAmelCase_							:       int       =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_token_classification(*snake_case_						)


  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       UpperCAmelCase_							:       Optional[int]       =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_flaubert_for_multiple_choice(*snake_case_						)






  @slow
  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCAmelCase_							:       Union[str, Any]       =				TFFlaubertModel.from_pretrained(snake_case_						)
            self.assertIsNotNone(snake_case_						)







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







  '''simple docstring'''






  @slow
  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       UpperCAmelCase_							:       Optional[int]       =				TFFlaubertModel.from_pretrained('jplu/tf-flaubert-small-cased'						)

       UpperCAmelCase_							:       Any       =				tf.convert_to_tensor(
           [[0, 1_5_8, 7_3_5, 2_5_9_2, 1_4_2_4, 6_7_2_7, 8_2, 1]]				,		dtype=tf.intaa				,		)  # "J'aime flaubert !"

       UpperCAmelCase_							:       int       =				model(snake_case_						)[0]
       UpperCAmelCase_							:       Any       =				tf.TensorShape((1, 8, 5_1_2)						)
       self.assertEqual(output.shape				,		snake_case_						)
       # compare the actual values for a slice.
       UpperCAmelCase_							:       Dict       =				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 collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig


snake_case__					:      Dict				      =  {
    '''albert-base-v1''': '''https://huggingface.co/albert-base-v1/resolve/main/config.json''',
    '''albert-large-v1''': '''https://huggingface.co/albert-large-v1/resolve/main/config.json''',
    '''albert-xlarge-v1''': '''https://huggingface.co/albert-xlarge-v1/resolve/main/config.json''',
    '''albert-xxlarge-v1''': '''https://huggingface.co/albert-xxlarge-v1/resolve/main/config.json''',
    '''albert-base-v2''': '''https://huggingface.co/albert-base-v2/resolve/main/config.json''',
    '''albert-large-v2''': '''https://huggingface.co/albert-large-v2/resolve/main/config.json''',
    '''albert-xlarge-v2''': '''https://huggingface.co/albert-xlarge-v2/resolve/main/config.json''',
    '''albert-xxlarge-v2''': '''https://huggingface.co/albert-xxlarge-v2/resolve/main/config.json''',
}






class 					__SCREAMING_SNAKE_CASE						(	lowerCamelCase_	):







  '''simple docstring'''






  lowerCamelCase_		:str						   =		'''albert'''


  def __init__(			self				,		snake_case_=3_0_0_0_0				,		snake_case_=1_2_8				,		snake_case_=4_0_9_6				,		snake_case_=1_2				,		snake_case_=1				,		snake_case_=6_4				,		snake_case_=1_6_3_8_4				,		snake_case_=1				,		snake_case_="gelu_new"				,		snake_case_=0				,		snake_case_=0				,		snake_case_=5_1_2				,		snake_case_=2				,		snake_case_=0.02				,		snake_case_=1E-12				,		snake_case_=0.1				,		snake_case_="absolute"				,		snake_case_=0				,		snake_case_=2				,		snake_case_=3				,		**snake_case_				,		):




       '''simple docstring'''

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

       UpperCAmelCase_							:       List[Any]       =				vocab_size
       UpperCAmelCase_							:       Dict       =				embedding_size
       UpperCAmelCase_							:       str       =				hidden_size
       UpperCAmelCase_							:       Any       =				num_hidden_layers
       UpperCAmelCase_							:       Union[str, Any]       =				num_hidden_groups
       UpperCAmelCase_							:       List[str]       =				num_attention_heads
       UpperCAmelCase_							:       Any       =				inner_group_num
       UpperCAmelCase_							:       Optional[int]       =				hidden_act
       UpperCAmelCase_							:       Tuple       =				intermediate_size
       UpperCAmelCase_							:       Any       =				hidden_dropout_prob
       UpperCAmelCase_							:       List[str]       =				attention_probs_dropout_prob
       UpperCAmelCase_							:       Union[str, Any]       =				max_position_embeddings
       UpperCAmelCase_							:       Dict       =				type_vocab_size
       UpperCAmelCase_							:       Union[str, Any]       =				initializer_range
       UpperCAmelCase_							:       Optional[Any]       =				layer_norm_eps
       UpperCAmelCase_							:       Dict       =				classifier_dropout_prob
       UpperCAmelCase_							:       Tuple       =				position_embedding_type







class 					__SCREAMING_SNAKE_CASE						(	lowerCamelCase_	):







  '''simple docstring'''






  @property
  def _UpperCamelCase					(			self						):




       '''simple docstring'''

       if self.task == "multiple-choice":
            UpperCAmelCase_							:       Optional[Any]       =				{0: 'batch', 1: 'choice', 2: 'sequence'}
       else:
            UpperCAmelCase_							:       List[Any]       =				{0: 'batch', 1: 'sequence'}
       return OrderedDict(
           [
               ('input_ids', dynamic_axis),
               ('attention_mask', dynamic_axis),
               ('token_type_ids', dynamic_axis),
           ]						)






