


'''simple docstring'''



from __future__ import annotations

import unittest

from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
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 import (
      TF_MODEL_FOR_PRETRAINING_MAPPING,
      TFMobileBertForMaskedLM,
      TFMobileBertForMultipleChoice,
      TFMobileBertForNextSentencePrediction,
      TFMobileBertForPreTraining,
      TFMobileBertForQuestionAnswering,
      TFMobileBertForSequenceClassification,
      TFMobileBertForTokenClassification,
      TFMobileBertModel,
  )


@require_tf
class 		_snake_case					(     a__       ,   a__       ,   unittest.TestCase	):
     lowerCAmelCase      :Optional[int]   =					(
         (
             TFMobileBertModel,
             TFMobileBertForMaskedLM,
             TFMobileBertForNextSentencePrediction,
             TFMobileBertForPreTraining,
             TFMobileBertForQuestionAnswering,
             TFMobileBertForSequenceClassification,
             TFMobileBertForTokenClassification,
             TFMobileBertForMultipleChoice,
         )
         if is_tf_available()
         else ()
     )
     lowerCAmelCase      :Union[str, Any]   =					(
         {
             '''feature-extraction''': TFMobileBertModel,
             '''fill-mask''': TFMobileBertForMaskedLM,
             '''question-answering''': TFMobileBertForQuestionAnswering,
             '''text-classification''': TFMobileBertForSequenceClassification,
             '''token-classification''': TFMobileBertForTokenClassification,
             '''zero-shot''': TFMobileBertForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     lowerCAmelCase      :Optional[Any]   =					False
     lowerCAmelCase      :Dict   =					False




     def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase=False):
        UpperCAmelCase__  :					int        =     super()._prepare_for_class(_lowerCamelCase							,							_lowerCamelCase							,							return_labels=_lowerCamelCase)

        if return_labels:
           if model_class in get_values(_lowerCamelCase):
              UpperCAmelCase__  :					Tuple        =     tf.zeros(self.model_tester.batch_size							,							dtype=tf.intaa)

        return inputs_dict


     class 		_snake_case					(     a__	):




          def __init__(      self							,							_lowerCamelCase							,							_lowerCamelCase=13							,							_lowerCamelCase=7							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=99							,							_lowerCamelCase=32							,							_lowerCamelCase=32							,							_lowerCamelCase=2							,							_lowerCamelCase=4							,							_lowerCamelCase=37							,							_lowerCamelCase="gelu"							,							_lowerCamelCase=0.1							,							_lowerCamelCase=0.1							,							_lowerCamelCase=512							,							_lowerCamelCase=16							,							_lowerCamelCase=2							,							_lowerCamelCase=0.02							,							_lowerCamelCase=3							,							_lowerCamelCase=4							,							_lowerCamelCase=None							,							):
             UpperCAmelCase__  :					Optional[Any]        =     parent
             UpperCAmelCase__  :					List[str]        =     batch_size
             UpperCAmelCase__  :					Any        =     seq_length
             UpperCAmelCase__  :					Dict        =     is_training
             UpperCAmelCase__  :					str        =     use_input_mask
             UpperCAmelCase__  :					int        =     use_token_type_ids
             UpperCAmelCase__  :					Optional[Any]        =     use_labels
             UpperCAmelCase__  :					Any        =     vocab_size
             UpperCAmelCase__  :					Optional[Any]        =     hidden_size
             UpperCAmelCase__  :					Optional[int]        =     num_hidden_layers
             UpperCAmelCase__  :					List[Any]        =     num_attention_heads
             UpperCAmelCase__  :					Dict        =     intermediate_size
             UpperCAmelCase__  :					str        =     hidden_act
             UpperCAmelCase__  :					int        =     hidden_dropout_prob
             UpperCAmelCase__  :					Union[str, Any]        =     attention_probs_dropout_prob
             UpperCAmelCase__  :					Optional[int]        =     max_position_embeddings
             UpperCAmelCase__  :					Union[str, Any]        =     type_vocab_size
             UpperCAmelCase__  :					Optional[int]        =     type_sequence_label_size
             UpperCAmelCase__  :					Optional[int]        =     initializer_range
             UpperCAmelCase__  :					Union[str, Any]        =     num_labels
             UpperCAmelCase__  :					List[str]        =     num_choices
             UpperCAmelCase__  :					str        =     scope
             UpperCAmelCase__  :					Optional[int]        =     embedding_size




          def 				snake_case__						(      self):
             UpperCAmelCase__  :					str        =     ids_tensor([self.batch_size, self.seq_length]							,							self.vocab_size)

             UpperCAmelCase__  :					Optional[Any]        =     None
             if self.use_input_mask:
                UpperCAmelCase__  :					Tuple        =     random_attention_mask([self.batch_size, self.seq_length])

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

             UpperCAmelCase__  :					int        =     None
             UpperCAmelCase__  :					List[Any]        =     None
             UpperCAmelCase__  :					Any        =     None
             if self.use_labels:
                UpperCAmelCase__  :					Dict        =     ids_tensor([self.batch_size]							,							self.type_sequence_label_size)
                UpperCAmelCase__  :					Optional[Any]        =     ids_tensor([self.batch_size, self.seq_length]							,							self.num_labels)
                UpperCAmelCase__  :					Optional[int]        =     ids_tensor([self.batch_size]							,							self.num_choices)

             UpperCAmelCase__  :					str        =     MobileBertConfig(
                 vocab_size=self.vocab_size							,							hidden_size=self.hidden_size							,							num_hidden_layers=self.num_hidden_layers							,							num_attention_heads=self.num_attention_heads							,							intermediate_size=self.intermediate_size							,							hidden_act=self.hidden_act							,							hidden_dropout_prob=self.hidden_dropout_prob							,							attention_probs_dropout_prob=self.attention_probs_dropout_prob							,							max_position_embeddings=self.max_position_embeddings							,							type_vocab_size=self.type_vocab_size							,							initializer_range=self.initializer_range							,							embedding_size=self.embedding_size							,							)

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




          def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
             UpperCAmelCase__  :					str        =     TFMobileBertModel(config=_lowerCamelCase)
             UpperCAmelCase__  :					Dict        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             UpperCAmelCase__  :					int        =     model(_lowerCamelCase)

             UpperCAmelCase__  :					Dict        =     [input_ids, input_mask]
             UpperCAmelCase__  :					List[Any]        =     model(_lowerCamelCase)

             UpperCAmelCase__  :					Optional[int]        =     model(_lowerCamelCase)

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




          def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
             UpperCAmelCase__  :					List[str]        =     TFMobileBertForMaskedLM(config=_lowerCamelCase)
             UpperCAmelCase__  :					List[str]        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             UpperCAmelCase__  :					Dict        =     model(_lowerCamelCase)
             self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.seq_length, self.vocab_size))




          def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
             UpperCAmelCase__  :					Union[str, Any]        =     TFMobileBertForNextSentencePrediction(config=_lowerCamelCase)
             UpperCAmelCase__  :					str        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             UpperCAmelCase__  :					List[str]        =     model(_lowerCamelCase)
             self.parent.assertEqual(result.logits.shape							,							(self.batch_size, 2))




          def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
             UpperCAmelCase__  :					List[str]        =     TFMobileBertForPreTraining(config=_lowerCamelCase)
             UpperCAmelCase__  :					Optional[Any]        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             UpperCAmelCase__  :					Any        =     model(_lowerCamelCase)
             self.parent.assertEqual(
                 result.prediction_logits.shape							,							(self.batch_size, self.seq_length, self.vocab_size))
             self.parent.assertEqual(result.seq_relationship_logits.shape							,							(self.batch_size, 2))




          def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
             UpperCAmelCase__  :					Any        =     self.num_labels
             UpperCAmelCase__  :					Optional[Any]        =     TFMobileBertForSequenceClassification(config=_lowerCamelCase)
             UpperCAmelCase__  :					Optional[int]        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             UpperCAmelCase__  :					Tuple        =     model(_lowerCamelCase)
             self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.num_labels))




          def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
             UpperCAmelCase__  :					Tuple        =     self.num_choices
             UpperCAmelCase__  :					Dict        =     TFMobileBertForMultipleChoice(config=_lowerCamelCase)
             UpperCAmelCase__  :					int        =     tf.tile(tf.expand_dims(_lowerCamelCase							,							1)							,							(1, self.num_choices, 1))
             UpperCAmelCase__  :					str        =     tf.tile(tf.expand_dims(_lowerCamelCase							,							1)							,							(1, self.num_choices, 1))
             UpperCAmelCase__  :					Optional[Any]        =     tf.tile(tf.expand_dims(_lowerCamelCase							,							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(_lowerCamelCase)
             self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.num_choices))




          def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
             UpperCAmelCase__  :					List[Any]        =     self.num_labels
             UpperCAmelCase__  :					Optional[Any]        =     TFMobileBertForTokenClassification(config=_lowerCamelCase)
             UpperCAmelCase__  :					Dict        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             UpperCAmelCase__  :					List[Any]        =     model(_lowerCamelCase)
             self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.seq_length, self.num_labels))




          def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
             UpperCAmelCase__  :					Any        =     TFMobileBertForQuestionAnswering(config=_lowerCamelCase)
             UpperCAmelCase__  :					Optional[int]        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
             UpperCAmelCase__  :					List[str]        =     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 				snake_case__						(      self):
             UpperCAmelCase__  :					Any        =     self.prepare_config_and_inputs()
             (
                 UpperCAmelCase__       
             )  :					Any        =     config_and_inputs
             UpperCAmelCase__  :					Union[str, Any]        =     {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
             return config, inputs_dict




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					str        =     TFMobileBertModelTest.TFMobileBertModelTester(self)
        UpperCAmelCase__  :					List[Any]        =     ConfigTester(self							,							config_class=_lowerCamelCase							,							hidden_size=37)




     def 				snake_case__						(      self):
        self.config_tester.run_common_tests()




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					int        =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_model(*_lowerCamelCase)




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					Optional[int]        =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_masked_lm(*_lowerCamelCase)




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					Optional[Any]        =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_multiple_choice(*_lowerCamelCase)




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					List[Any]        =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*_lowerCamelCase)




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					Optional[Any]        =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_pretraining(*_lowerCamelCase)




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					Any        =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_question_answering(*_lowerCamelCase)




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					str        =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_sequence_classification(*_lowerCamelCase)




     def 				snake_case__						(      self):
        UpperCAmelCase__  :					Tuple        =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_token_classification(*_lowerCamelCase)




     @slow
     def 				snake_case__						(      self):
        # for model_name in TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        for model_name in ["google/mobilebert-uncased"]:
           UpperCAmelCase__  :					Optional[Any]        =     TFMobileBertModel.from_pretrained(_lowerCamelCase)
           self.assertIsNotNone(_lowerCamelCase)


@require_tf
class 		_snake_case					(     unittest.TestCase	):




     @slow
     def 				snake_case__						(      self):
        UpperCAmelCase__  :					Any        =     TFMobileBertForPreTraining.from_pretrained("""google/mobilebert-uncased""")
        UpperCAmelCase__  :					str        =     tf.constant([[0, 1, 2, 3, 4, 5]])
        UpperCAmelCase__  :					Optional[int]        =     model(_lowerCamelCase)[0]

        UpperCAmelCase__  :					List[str]        =     [1, 6, 3_0522]
        self.assertEqual(output.shape							,							_lowerCamelCase)

        UpperCAmelCase__  :					List[Any]        =     tf.constant(
            [
                [
                    [-4.5919547, -9.248295, -9.645256],
                    [-6.7306175, -6.440284, -6.6052837],
                    [-7.2743506, -6.7847915, -6.024673],
                ]
            ])
        tf.debugging.assert_near(output[:, :3, :3]							,							_lowerCamelCase							,							atol=1e-4)



'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tensorflow_text_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__A	={
    'configuration_bert': ['BERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'BertConfig', 'BertOnnxConfig'],
    'tokenization_bert': ['BasicTokenizer', 'BertTokenizer', 'WordpieceTokenizer'],
}

try:
		if not is_tokenizers_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__A	=['BertTokenizerFast']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__A	=[
		    'BERT_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'BertForMaskedLM',
		    'BertForMultipleChoice',
		    'BertForNextSentencePrediction',
		    'BertForPreTraining',
		    'BertForQuestionAnswering',
		    'BertForSequenceClassification',
		    'BertForTokenClassification',
		    'BertLayer',
		    'BertLMHeadModel',
		    'BertModel',
		    'BertPreTrainedModel',
		    'load_tf_weights_in_bert',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__A	=[
		    'TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'TFBertEmbeddings',
		    'TFBertForMaskedLM',
		    'TFBertForMultipleChoice',
		    'TFBertForNextSentencePrediction',
		    'TFBertForPreTraining',
		    'TFBertForQuestionAnswering',
		    'TFBertForSequenceClassification',
		    'TFBertForTokenClassification',
		    'TFBertLMHeadModel',
		    'TFBertMainLayer',
		    'TFBertModel',
		    'TFBertPreTrainedModel',
		]
try:
		if not is_tensorflow_text_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__A	=['TFBertTokenizer']

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__A	=[
		    'FlaxBertForCausalLM',
		    'FlaxBertForMaskedLM',
		    'FlaxBertForMultipleChoice',
		    'FlaxBertForNextSentencePrediction',
		    'FlaxBertForPreTraining',
		    'FlaxBertForQuestionAnswering',
		    'FlaxBertForSequenceClassification',
		    'FlaxBertForTokenClassification',
		    'FlaxBertModel',
		    'FlaxBertPreTrainedModel',
		]

if TYPE_CHECKING:
		from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
		from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer

		try:
				if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_bert_fast import BertTokenizerFast

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_bert import (
				    BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    BertForMaskedLM,
				    BertForMultipleChoice,
				    BertForNextSentencePrediction,
				    BertForPreTraining,
				    BertForQuestionAnswering,
				    BertForSequenceClassification,
				    BertForTokenClassification,
				    BertLayer,
				    BertLMHeadModel,
				    BertModel,
				    BertPreTrainedModel,
				    load_tf_weights_in_bert,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_bert import (
				    TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFBertEmbeddings,
				    TFBertForMaskedLM,
				    TFBertForMultipleChoice,
				    TFBertForNextSentencePrediction,
				    TFBertForPreTraining,
				    TFBertForQuestionAnswering,
				    TFBertForSequenceClassification,
				    TFBertForTokenClassification,
				    TFBertLMHeadModel,
				    TFBertMainLayer,
				    TFBertModel,
				    TFBertPreTrainedModel,
				)

		try:
				if not is_tensorflow_text_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_bert_tf import TFBertTokenizer

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flax_bert import (
				    FlaxBertForCausalLM,
				    FlaxBertForMaskedLM,
				    FlaxBertForMultipleChoice,
				    FlaxBertForNextSentencePrediction,
				    FlaxBertForPreTraining,
				    FlaxBertForQuestionAnswering,
				    FlaxBertForSequenceClassification,
				    FlaxBertForTokenClassification,
				    FlaxBertModel,
				    FlaxBertPreTrainedModel,
				)

else:
		import sys

		__A	=_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)