



"""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       A_			(     _lowerCamelCase	,   _lowerCamelCase	,   unittest.TestCase				):



						"""simple docstring"""
						__UpperCamelCase						=							(
						    (
						        TFMobileBertModel,
						        TFMobileBertForMaskedLM,
						        TFMobileBertForNextSentencePrediction,
						        TFMobileBertForPreTraining,
						        TFMobileBertForQuestionAnswering,
						        TFMobileBertForSequenceClassification,
						        TFMobileBertForTokenClassification,
						        TFMobileBertForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						__UpperCamelCase						=							(
						    {
						        """feature-extraction""": TFMobileBertModel,
						        """fill-mask""": TFMobileBertForMaskedLM,
						        """question-answering""": TFMobileBertForQuestionAnswering,
						        """text-classification""": TFMobileBertForSequenceClassification,
						        """token-classification""": TFMobileBertForTokenClassification,
						        """zero-shot""": TFMobileBertForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						__UpperCamelCase						=							False
						__UpperCamelCase						=							False






						def 	UpperCAmelCase__     (					self :Dict   ,  lowercase_ :Tuple   ,  lowercase_ :Tuple   ,  lowercase_ :Union[str, Any]=False					)				->			str:
												UpperCAmelCase             = super()._prepare_for_class(lowercase_   ,  lowercase_   ,  return_labels=lowercase_					)

												if return_labels:
																		if model_class in get_values(lowercase_					):
																								UpperCAmelCase             = tf.zeros(self.model_tester.batch_size   ,  dtype=tf.intaa					)

												return inputs_dict







						class       A_			(     _lowerCamelCase				):



												"""simple docstring"""






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






												def 	UpperCAmelCase__     (					self :Union[str, Any]					)				->			Union[str, Any]:
																		UpperCAmelCase             = ids_tensor([self.batch_size, self.seq_length]   ,  self.vocab_size					)

																		UpperCAmelCase             = None
																		if self.use_input_mask:
																								UpperCAmelCase             = random_attention_mask([self.batch_size, self.seq_length]					)

																		UpperCAmelCase             = None
																		if self.use_token_type_ids:
																								UpperCAmelCase             = ids_tensor([self.batch_size, self.seq_length]   ,  self.type_vocab_size					)

																		UpperCAmelCase             = None
																		UpperCAmelCase             = None
																		UpperCAmelCase             = None
																		if self.use_labels:
																								UpperCAmelCase             = ids_tensor([self.batch_size]   ,  self.type_sequence_label_size					)
																								UpperCAmelCase             = ids_tensor([self.batch_size, self.seq_length]   ,  self.num_labels					)
																								UpperCAmelCase             = ids_tensor([self.batch_size]   ,  self.num_choices					)

																		UpperCAmelCase             = 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 	UpperCAmelCase__     (					self :List[Any]   ,  lowercase_ :int   ,  lowercase_ :Tuple   ,  lowercase_ :str   ,  lowercase_ :Union[str, Any]   ,  lowercase_ :Dict   ,  lowercase_ :List[Any]   ,  lowercase_ :Optional[int]					)				->			Union[str, Any]:
																		UpperCAmelCase             = TFMobileBertModel(config=lowercase_					)
																		UpperCAmelCase             = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase             = model(lowercase_					)

																		UpperCAmelCase             = [input_ids, input_mask]
																		UpperCAmelCase             = model(lowercase_					)

																		UpperCAmelCase             = model(lowercase_					)

																		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 	UpperCAmelCase__     (					self :List[str]   ,  lowercase_ :Union[str, Any]   ,  lowercase_ :str   ,  lowercase_ :Dict   ,  lowercase_ :str   ,  lowercase_ :int   ,  lowercase_ :Optional[Any]   ,  lowercase_ :Optional[int]					)				->			List[str]:
																		UpperCAmelCase             = TFMobileBertForMaskedLM(config=lowercase_					)
																		UpperCAmelCase             = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase             = model(lowercase_					)
																		self.parent.assertEqual(result.logits.shape   ,  (self.batch_size, self.seq_length, self.vocab_size)					)






												def 	UpperCAmelCase__     (					self :Union[str, Any]   ,  lowercase_ :Optional[int]   ,  lowercase_ :int   ,  lowercase_ :Union[str, Any]   ,  lowercase_ :Dict   ,  lowercase_ :Any   ,  lowercase_ :Optional[Any]   ,  lowercase_ :List[str]					)				->			Optional[int]:
																		UpperCAmelCase             = TFMobileBertForNextSentencePrediction(config=lowercase_					)
																		UpperCAmelCase             = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase             = model(lowercase_					)
																		self.parent.assertEqual(result.logits.shape   ,  (self.batch_size, 2)					)






												def 	UpperCAmelCase__     (					self :Dict   ,  lowercase_ :int   ,  lowercase_ :Optional[int]   ,  lowercase_ :Union[str, Any]   ,  lowercase_ :Union[str, Any]   ,  lowercase_ :Optional[Any]   ,  lowercase_ :Optional[Any]   ,  lowercase_ :Any					)				->			str:
																		UpperCAmelCase             = TFMobileBertForPreTraining(config=lowercase_					)
																		UpperCAmelCase             = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase             = model(lowercase_					)
																		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 	UpperCAmelCase__     (					self :Union[str, Any]   ,  lowercase_ :Union[str, Any]   ,  lowercase_ :str   ,  lowercase_ :Optional[int]   ,  lowercase_ :Dict   ,  lowercase_ :Any   ,  lowercase_ :Union[str, Any]   ,  lowercase_ :Tuple					)				->			Dict:
																		UpperCAmelCase             = self.num_labels
																		UpperCAmelCase             = TFMobileBertForSequenceClassification(config=lowercase_					)
																		UpperCAmelCase             = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase             = model(lowercase_					)
																		self.parent.assertEqual(result.logits.shape   ,  (self.batch_size, self.num_labels)					)






												def 	UpperCAmelCase__     (					self :List[Any]   ,  lowercase_ :Optional[Any]   ,  lowercase_ :Dict   ,  lowercase_ :int   ,  lowercase_ :Optional[int]   ,  lowercase_ :int   ,  lowercase_ :Tuple   ,  lowercase_ :Any					)				->			Union[str, Any]:
																		UpperCAmelCase             = self.num_choices
																		UpperCAmelCase             = TFMobileBertForMultipleChoice(config=lowercase_					)
																		UpperCAmelCase             = tf.tile(tf.expand_dims(lowercase_   ,  1					)   ,  (1, self.num_choices, 1)					)
																		UpperCAmelCase             = tf.tile(tf.expand_dims(lowercase_   ,  1					)   ,  (1, self.num_choices, 1)					)
																		UpperCAmelCase             = tf.tile(tf.expand_dims(lowercase_   ,  1					)   ,  (1, self.num_choices, 1)					)
																		UpperCAmelCase             = {
																		    'input_ids': multiple_choice_inputs_ids,
																		    'attention_mask': multiple_choice_input_mask,
																		    'token_type_ids': multiple_choice_token_type_ids,
																		}
																		UpperCAmelCase             = model(lowercase_					)
																		self.parent.assertEqual(result.logits.shape   ,  (self.batch_size, self.num_choices)					)






												def 	UpperCAmelCase__     (					self :Union[str, Any]   ,  lowercase_ :int   ,  lowercase_ :Dict   ,  lowercase_ :Optional[Any]   ,  lowercase_ :int   ,  lowercase_ :Optional[Any]   ,  lowercase_ :Union[str, Any]   ,  lowercase_ :Any					)				->			Dict:
																		UpperCAmelCase             = self.num_labels
																		UpperCAmelCase             = TFMobileBertForTokenClassification(config=lowercase_					)
																		UpperCAmelCase             = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase             = model(lowercase_					)
																		self.parent.assertEqual(result.logits.shape   ,  (self.batch_size, self.seq_length, self.num_labels)					)






												def 	UpperCAmelCase__     (					self :List[Any]   ,  lowercase_ :Optional[int]   ,  lowercase_ :int   ,  lowercase_ :Any   ,  lowercase_ :Any   ,  lowercase_ :Optional[int]   ,  lowercase_ :List[Any]   ,  lowercase_ :Tuple					)				->			Any:
																		UpperCAmelCase             = TFMobileBertForQuestionAnswering(config=lowercase_					)
																		UpperCAmelCase             = {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase             = 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 :int					)				->			Any:
																		UpperCAmelCase             = self.prepare_config_and_inputs()
																		(
																		    (
																		    UpperCAmelCase
																		)      ,    (
																		    UpperCAmelCase
																		)      ,    (
																		    UpperCAmelCase
																		)      ,    (
																		    UpperCAmelCase
																		)      ,    (
																		    UpperCAmelCase
																		)      ,    (
																		    UpperCAmelCase
																		)      ,    (
																		    UpperCAmelCase
																		)      ,    
																		)             = config_and_inputs
																		UpperCAmelCase             = {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
																		return config, inputs_dict






						def 	UpperCAmelCase__     (					self :str					)				->			Tuple:
												UpperCAmelCase             = TFMobileBertModelTest.TFMobileBertModelTester(self					)
												UpperCAmelCase             = ConfigTester(self   ,  config_class=lowercase_   ,  hidden_size=37					)






						def 	UpperCAmelCase__     (					self :int					)				->			Tuple:
												self.config_tester.run_common_tests()






						def 	UpperCAmelCase__     (					self :str					)				->			Tuple:
												UpperCAmelCase             = self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_model(*lowercase_					)






						def 	UpperCAmelCase__     (					self :Dict					)				->			Tuple:
												UpperCAmelCase             = self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_masked_lm(*lowercase_					)






						def 	UpperCAmelCase__     (					self :Any					)				->			List[str]:
												UpperCAmelCase             = self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_multiple_choice(*lowercase_					)






						def 	UpperCAmelCase__     (					self :Union[str, Any]					)				->			Optional[int]:
												UpperCAmelCase             = self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*lowercase_					)






						def 	UpperCAmelCase__     (					self :Any					)				->			List[Any]:
												UpperCAmelCase             = self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_pretraining(*lowercase_					)






						def 	UpperCAmelCase__     (					self :List[Any]					)				->			List[str]:
												UpperCAmelCase             = self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_question_answering(*lowercase_					)






						def 	UpperCAmelCase__     (					self :Optional[Any]					)				->			Any:
												UpperCAmelCase             = self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_sequence_classification(*lowercase_					)






						def 	UpperCAmelCase__     (					self :List[str]					)				->			Dict:
												UpperCAmelCase             = self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_token_classification(*lowercase_					)






						@slow
						def 	UpperCAmelCase__     (					self :List[str]					)				->			Tuple:
												# for model_name in TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												for model_name in ["google/mobilebert-uncased"]:
																		UpperCAmelCase             = TFMobileBertModel.from_pretrained(lowercase_					)
																		self.assertIsNotNone(lowercase_					)







@require_tf
class       A_			(     unittest.TestCase				):



						"""simple docstring"""






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

												UpperCAmelCase             = [1, 6, 3_05_22]
												self.assertEqual(output.shape   ,  lowercase_					)

												UpperCAmelCase             = tf.constant(
												    [
												        [
												            [-4.591_9547, -9.24_8295, -9.64_5256],
												            [-6.730_6175, -6.44_0284, -6.605_2837],
												            [-7.274_3506, -6.784_7915, -6.02_4673],
												        ]
												    ]					)
												tf.debugging.assert_near(output[:, :3, :3]   ,  lowercase_   ,  atol=1E-4					)











'''simple docstring'''

from ..utils import DummyObject, requires_backends






class 						a				(   metaclass=_lowerCamelCase     ):
				snake_case_      =		["transformers", "torch", "note_seq"]


				def __init__(		self    :					Union[str, Any]       ,				*lowercase_    :					Optional[int]       ,				**lowercase_    :					int					):
									requires_backends(self       ,				['''transformers''', '''torch''', '''note_seq''']					)


				@classmethod
				def   A_ (		cls    :					List[Any]       ,				*lowercase_    :					Optional[Any]       ,				**lowercase_    :					str					):
									requires_backends(cls       ,				['''transformers''', '''torch''', '''note_seq''']					)


				@classmethod
				def   A_ (		cls    :					Tuple       ,				*lowercase_    :					Union[str, Any]       ,				**lowercase_    :					List[Any]					):
									requires_backends(cls       ,				['''transformers''', '''torch''', '''note_seq''']					)

