
"""simple docstring"""




import re
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin



class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				__UpperCamelCase   :		Dict       =     ['''image_processor''', '''tokenizer''']
				__UpperCamelCase   :		List[Any]       =     '''AutoImageProcessor'''
				__UpperCamelCase   :		Optional[int]       =     '''AutoTokenizer'''



				def __init__(self     , SCREAMING_SNAKE_CASE__=None     , SCREAMING_SNAKE_CASE__=None     , **SCREAMING_SNAKE_CASE__					)      ->	Optional[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     None
											if "feature_extractor" in kwargs:
																		warnings.warn(
																		    """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
																		    """ instead."""     , SCREAMING_SNAKE_CASE__     , )
																		SCREAMING_SNAKE_CASE__		: Optional[Any]     =     kwargs.pop("""feature_extractor"""					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     image_processor if image_processor is not None else feature_extractor
											if image_processor is None:
																		raise ValueError("""You need to specify an `image_processor`."""					)
											if tokenizer is None:
																		raise ValueError("""You need to specify a `tokenizer`."""					)

											super().__init__(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     self.image_processor
											SCREAMING_SNAKE_CASE__		: Any     =     False



				def __call__(self     , *SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)      ->	str:



											"""simple docstring"""




											if self._in_target_context_manager:
																		return self.current_processor(*SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     kwargs.pop("""images"""     , SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     kwargs.pop("""text"""     , SCREAMING_SNAKE_CASE__					)
											if len(SCREAMING_SNAKE_CASE__					) > 0:
																		SCREAMING_SNAKE_CASE__		: Dict     =     args[0]
																		SCREAMING_SNAKE_CASE__		: List[str]     =     args[1:]

											if images is None and text is None:
																		raise ValueError("""You need to specify either an `images` or `text` input to process."""					)

											if images is not None:
																		SCREAMING_SNAKE_CASE__		: str     =     self.image_processor(SCREAMING_SNAKE_CASE__     , *SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)
											if text is not None:
																		SCREAMING_SNAKE_CASE__		: int     =     self.tokenizer(SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)

											if text is None:
																		return inputs
											elif images is None:
																		return encodings
											else:
																		SCREAMING_SNAKE_CASE__		: Optional[int]     =     encodings["""input_ids"""]
																		return inputs



				def 			__magic_name__					(self     , *SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



											"""simple docstring"""




											return self.tokenizer.batch_decode(*SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self     , *SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



											"""simple docstring"""




											return self.tokenizer.decode(*SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)



				@contextmanager
				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											warnings.warn(
											    """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """
											    """labels by using the argument `text` of the regular `__call__` method (either in the same call as """
											    """your images inputs, or in a separate call."""					)
											SCREAMING_SNAKE_CASE__		: int     =     True
											SCREAMING_SNAKE_CASE__		: Tuple     =     self.tokenizer
											yield
											SCREAMING_SNAKE_CASE__		: int     =     self.image_processor
											SCREAMING_SNAKE_CASE__		: Dict     =     False



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__=False     , SCREAMING_SNAKE_CASE__=None					)      ->	Tuple:



											"""simple docstring"""




											if added_vocab is None:
																		SCREAMING_SNAKE_CASE__		: List[Any]     =     self.tokenizer.get_added_vocab()

											SCREAMING_SNAKE_CASE__		: Dict     =     {}

											while tokens:
																		SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     re.search(r"""<s_(.*?)>"""     , SCREAMING_SNAKE_CASE__     , re.IGNORECASE					)
																		if start_token is None:
																									break
																		SCREAMING_SNAKE_CASE__		: Any     =     start_token.group(1					)
																		SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     re.search(rF'''</s_{key}>'''     , SCREAMING_SNAKE_CASE__     , re.IGNORECASE					)
																		SCREAMING_SNAKE_CASE__		: Optional[Any]     =     start_token.group()
																		if end_token is None:
																									SCREAMING_SNAKE_CASE__		: List[str]     =     tokens.replace(SCREAMING_SNAKE_CASE__     , """"""					)
																		else:
																									SCREAMING_SNAKE_CASE__		: Optional[int]     =     end_token.group()
																									SCREAMING_SNAKE_CASE__		: Dict     =     re.escape(SCREAMING_SNAKE_CASE__					)
																									SCREAMING_SNAKE_CASE__		: List[Any]     =     re.escape(SCREAMING_SNAKE_CASE__					)
																									SCREAMING_SNAKE_CASE__		: List[Any]     =     re.search(F'''{start_token_escaped}(.*?){end_token_escaped}'''     , SCREAMING_SNAKE_CASE__     , re.IGNORECASE					)
																									if content is not None:
																																SCREAMING_SNAKE_CASE__		: Optional[Any]     =     content.group(1					).strip()
																																if r"<s_" in content and r"</s_" in content:  # non-leaf node
																																							SCREAMING_SNAKE_CASE__		: Optional[Any]     =     self.tokenajson(SCREAMING_SNAKE_CASE__     , is_inner_value=SCREAMING_SNAKE_CASE__     , added_vocab=SCREAMING_SNAKE_CASE__					)
																																							if value:
																																														if len(SCREAMING_SNAKE_CASE__					) == 1:
																																																					SCREAMING_SNAKE_CASE__		: str     =     value[0]
																																														SCREAMING_SNAKE_CASE__		: int     =     value
																																else:  # leaf nodes
																																							SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     []
																																							for leaf in content.split(r"""<sep/>"""					):
																																														SCREAMING_SNAKE_CASE__		: str     =     leaf.strip()
																																														if leaf in added_vocab and leaf[0] == "<" and leaf[-2:] == "/>":
																																																					SCREAMING_SNAKE_CASE__		: List[str]     =     leaf[1:-2]  # for categorical special tokens
																																														output[key].append(SCREAMING_SNAKE_CASE__					)
																																							if len(output[key]					) == 1:
																																														SCREAMING_SNAKE_CASE__		: Dict     =     output[key][0]

																									SCREAMING_SNAKE_CASE__		: List[str]     =     tokens[tokens.find(SCREAMING_SNAKE_CASE__					) + len(SCREAMING_SNAKE_CASE__					) :].strip()
																									if tokens[:6] == r"<sep/>":  # non-leaf nodes
																																return [output] + self.tokenajson(tokens[6:]     , is_inner_value=SCREAMING_SNAKE_CASE__     , added_vocab=SCREAMING_SNAKE_CASE__					)

											if len(SCREAMING_SNAKE_CASE__					):
																		return [output] if is_inner_value else output
											else:
																		return [] if is_inner_value else {"text_sequence": tokens}



				@property
				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											warnings.warn(
											    """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""     , SCREAMING_SNAKE_CASE__     , )
											return self.image_processor_class



				@property
				def 			__magic_name__					(self					)      ->	str:



											"""simple docstring"""




											warnings.warn(
											    """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""     , SCREAMING_SNAKE_CASE__     , )
											return self.image_processor






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


				"""simple docstring"""



				__UpperCamelCase   :		Any       =     (
				    (
				        TFMobileBertModel,
				        TFMobileBertForMaskedLM,
				        TFMobileBertForNextSentencePrediction,
				        TFMobileBertForPreTraining,
				        TFMobileBertForQuestionAnswering,
				        TFMobileBertForSequenceClassification,
				        TFMobileBertForTokenClassification,
				        TFMobileBertForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				__UpperCamelCase   :		Tuple       =     (
				    {
				        '''feature-extraction''': TFMobileBertModel,
				        '''fill-mask''': TFMobileBertForMaskedLM,
				        '''question-answering''': TFMobileBertForQuestionAnswering,
				        '''text-classification''': TFMobileBertForSequenceClassification,
				        '''token-classification''': TFMobileBertForTokenClassification,
				        '''zero-shot''': TFMobileBertForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				__UpperCamelCase   :		Optional[int]       =     False
				__UpperCamelCase   :		str       =     False



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__=False					)      ->	List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     super()._prepare_for_class(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , return_labels=SCREAMING_SNAKE_CASE__					)

											if return_labels:
																		if model_class in get_values(SCREAMING_SNAKE_CASE__					):
																									SCREAMING_SNAKE_CASE__		: List[str]     =     tf.zeros(self.model_tester.batch_size     , dtype=tf.intaa					)

											return inputs_dict



				class 			lowerCAmelCase_		(a__						):


								"""simple docstring"""



								def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__=13     , SCREAMING_SNAKE_CASE__=7     , SCREAMING_SNAKE_CASE__=True     , SCREAMING_SNAKE_CASE__=True     , SCREAMING_SNAKE_CASE__=True     , SCREAMING_SNAKE_CASE__=True     , SCREAMING_SNAKE_CASE__=99     , SCREAMING_SNAKE_CASE__=32     , SCREAMING_SNAKE_CASE__=32     , SCREAMING_SNAKE_CASE__=2     , SCREAMING_SNAKE_CASE__=4     , SCREAMING_SNAKE_CASE__=37     , SCREAMING_SNAKE_CASE__="gelu"     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=5_12     , SCREAMING_SNAKE_CASE__=16     , SCREAMING_SNAKE_CASE__=2     , SCREAMING_SNAKE_CASE__=0.02     , SCREAMING_SNAKE_CASE__=3     , SCREAMING_SNAKE_CASE__=4     , SCREAMING_SNAKE_CASE__=None     , )      ->	Optional[Any]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: Tuple     =     parent
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     batch_size
															SCREAMING_SNAKE_CASE__		: List[Any]     =     seq_length
															SCREAMING_SNAKE_CASE__		: Any     =     is_training
															SCREAMING_SNAKE_CASE__		: List[str]     =     use_input_mask
															SCREAMING_SNAKE_CASE__		: List[Any]     =     use_token_type_ids
															SCREAMING_SNAKE_CASE__		: List[Any]     =     use_labels
															SCREAMING_SNAKE_CASE__		: Optional[int]     =     vocab_size
															SCREAMING_SNAKE_CASE__		: int     =     hidden_size
															SCREAMING_SNAKE_CASE__		: List[Any]     =     num_hidden_layers
															SCREAMING_SNAKE_CASE__		: List[str]     =     num_attention_heads
															SCREAMING_SNAKE_CASE__		: List[str]     =     intermediate_size
															SCREAMING_SNAKE_CASE__		: List[Any]     =     hidden_act
															SCREAMING_SNAKE_CASE__		: Optional[int]     =     hidden_dropout_prob
															SCREAMING_SNAKE_CASE__		: Dict     =     attention_probs_dropout_prob
															SCREAMING_SNAKE_CASE__		: Optional[Any]     =     max_position_embeddings
															SCREAMING_SNAKE_CASE__		: Dict     =     type_vocab_size
															SCREAMING_SNAKE_CASE__		: Optional[int]     =     type_sequence_label_size
															SCREAMING_SNAKE_CASE__		: str     =     initializer_range
															SCREAMING_SNAKE_CASE__		: str     =     num_labels
															SCREAMING_SNAKE_CASE__		: Dict     =     num_choices
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     scope
															SCREAMING_SNAKE_CASE__		: Dict     =     embedding_size



								def 			__magic_name__					(self					)      ->	List[str]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: List[str]     =     ids_tensor([self.batch_size, self.seq_length]     , self.vocab_size					)

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

															SCREAMING_SNAKE_CASE__		: List[Any]     =     None
															if self.use_token_type_ids:
																						SCREAMING_SNAKE_CASE__		: int     =     ids_tensor([self.batch_size, self.seq_length]     , self.type_vocab_size					)

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

															SCREAMING_SNAKE_CASE__		: Optional[Any]     =     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 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Optional[int]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: str     =     TFMobileBertModel(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: int     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: List[Any]     =     model(SCREAMING_SNAKE_CASE__					)

															SCREAMING_SNAKE_CASE__		: Dict     =     [input_ids, input_mask]
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     model(SCREAMING_SNAKE_CASE__					)

															SCREAMING_SNAKE_CASE__		: List[str]     =     model(SCREAMING_SNAKE_CASE__					)

															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 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Any:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: Any     =     TFMobileBertForMaskedLM(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: Optional[Any]     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: List[str]     =     model(SCREAMING_SNAKE_CASE__					)
															self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.seq_length, self.vocab_size)					)



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	str:



															"""simple docstring"""




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



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     TFMobileBertForPreTraining(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: List[Any]     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     model(SCREAMING_SNAKE_CASE__					)
															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 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	int:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: List[Any]     =     self.num_labels
															SCREAMING_SNAKE_CASE__		: List[Any]     =     TFMobileBertForSequenceClassification(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: str     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     model(SCREAMING_SNAKE_CASE__					)
															self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.num_labels)					)



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Tuple:



															"""simple docstring"""




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



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: str     =     self.num_labels
															SCREAMING_SNAKE_CASE__		: Tuple     =     TFMobileBertForTokenClassification(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: Optional[Any]     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: List[str]     =     model(SCREAMING_SNAKE_CASE__					)
															self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.seq_length, self.num_labels)					)



								def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Optional[Any]:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: Any     =     TFMobileBertForQuestionAnswering(config=SCREAMING_SNAKE_CASE__					)
															SCREAMING_SNAKE_CASE__		: Dict     =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
															SCREAMING_SNAKE_CASE__		: str     =     model(SCREAMING_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 			__magic_name__					(self					)      ->	Dict:



															"""simple docstring"""




															SCREAMING_SNAKE_CASE__		: Tuple     =     self.prepare_config_and_inputs()
															(
															    (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   (
															    SCREAMING_SNAKE_CASE__
															)   ,   
															)		: List[Any]     =     config_and_inputs
															SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
															return config, inputs_dict






				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     TFMobileBertModelTest.TFMobileBertModelTester(self					)
											SCREAMING_SNAKE_CASE__		: str     =     ConfigTester(self     , config_class=SCREAMING_SNAKE_CASE__     , hidden_size=37					)



				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											self.config_tester.run_common_tests()



				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: str     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_model(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_masked_lm(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_multiple_choice(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_pretraining(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_question_answering(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: str     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_sequence_classification(*SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mobilebert_for_token_classification(*SCREAMING_SNAKE_CASE__					)



				@slow
				def 			__magic_name__					(self					)      ->	List[str]:



											"""simple docstring"""




											for model_name in ["google/mobilebert-uncased"]:
																		SCREAMING_SNAKE_CASE__		: Optional[Any]     =     TFMobileBertModel.from_pretrained(SCREAMING_SNAKE_CASE__					)
																		self.assertIsNotNone(SCREAMING_SNAKE_CASE__					)






@require_tf
class 			lowerCAmelCase_		(unittest.TestCase						):


				"""simple docstring"""



				@slow
				def 			__magic_name__					(self					)      ->	List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     TFMobileBertForPreTraining.from_pretrained("""google/mobilebert-uncased"""					)
											SCREAMING_SNAKE_CASE__		: List[Any]     =     tf.constant([[0, 1, 2, 3, 4, 5]]					)
											SCREAMING_SNAKE_CASE__		: Dict     =     model(SCREAMING_SNAKE_CASE__					)[0]

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     [1, 6, 3_05_22]
											self.assertEqual(output.shape     , SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: 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]     , SCREAMING_SNAKE_CASE__     , atol=1E-4					)




