
"""simple docstring"""




import unittest

from transformers import MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING, AutoTokenizer, is_vision_available
from transformers.pipelines import pipeline
from transformers.pipelines.document_question_answering import apply_tesseract
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_detectrona,
    require_pytesseract,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
							from PIL import Image

							from transformers.image_utils import load_image
else:



							class 			lowerCAmelCase_		:


											"""simple docstring"""



											@staticmethod
											def 			__magic_name__					(*SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)      ->	Union[str, Any]:



																		"""simple docstring"""




																		pass






							def lowercase_						(     _snake_case		):
														return None


# This is a pinned image from a specific revision of a document question answering space, hosted by HuggingFace,
# so we can expect it to be available.
UpperCAmelCase__   :					str												=				(
    'https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'
)



@is_pipeline_test
@require_torch
@require_vision
class 			lowerCAmelCase_		(unittest.TestCase						):


				"""simple docstring"""



				__UpperCamelCase   :		List[Any]       =     MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     pipeline(
											    """document-question-answering"""     , model=SCREAMING_SNAKE_CASE__     , tokenizer=SCREAMING_SNAKE_CASE__     , image_processor=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     list(zip(*apply_tesseract(load_image(SCREAMING_SNAKE_CASE__					)     , SCREAMING_SNAKE_CASE__     , """"""					)					)					)
											SCREAMING_SNAKE_CASE__		: Any     =     """What is the placebo?"""
											SCREAMING_SNAKE_CASE__		: Dict     =     [
											    {
											        """image""": load_image(SCREAMING_SNAKE_CASE__					),
											        """question""": question,
											    },
											    {
											        """image""": image,
											        """question""": question,
											    },
											    {
											        """image""": image,
											        """question""": question,
											        """word_boxes""": word_boxes,
											    },
											]
											return dqa_pipeline, examples



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     dqa_pipeline(SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(
											    SCREAMING_SNAKE_CASE__     , [
											        [
											            {"""score""": ANY(SCREAMING_SNAKE_CASE__					), """answer""": ANY(SCREAMING_SNAKE_CASE__					), """start""": ANY(SCREAMING_SNAKE_CASE__					), """end""": ANY(SCREAMING_SNAKE_CASE__					)},
											            {"""score""": ANY(SCREAMING_SNAKE_CASE__					), """answer""": ANY(SCREAMING_SNAKE_CASE__					), """start""": ANY(SCREAMING_SNAKE_CASE__					), """end""": ANY(SCREAMING_SNAKE_CASE__					)},
											        ]
											    ]
											    * 3     , )



				@require_torch
				@require_detectrona
				@require_pytesseract
				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[Any]     =     pipeline("""document-question-answering"""     , model="""hf-internal-testing/tiny-random-layoutlmv2"""					)
											SCREAMING_SNAKE_CASE__		: str     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Any     =     """How many cats are there?"""

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     [
											    {"""score""": 0.0001, """answer""": """oy 2312/2019""", """start""": 38, """end""": 39},
											    {"""score""": 0.0001, """answer""": """oy 2312/2019 DUE""", """start""": 38, """end""": 40},
											]
											SCREAMING_SNAKE_CASE__		: Any     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: str     =     dqa_pipeline({"""image""": image, """question""": question}     , top_k=2					)
											self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , SCREAMING_SNAKE_CASE__					)

											# This image does not detect ANY text in it, meaning layoutlmv2 should fail.
											# Empty answer probably
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     """./tests/fixtures/tests_samples/COCO/000000039769.png"""
											SCREAMING_SNAKE_CASE__		: List[str]     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(SCREAMING_SNAKE_CASE__     , []					)

											# We can optionnally pass directly the words and bounding boxes
											SCREAMING_SNAKE_CASE__		: Tuple     =     """./tests/fixtures/tests_samples/COCO/000000039769.png"""
											SCREAMING_SNAKE_CASE__		: Dict     =     []
											SCREAMING_SNAKE_CASE__		: Any     =     []
											SCREAMING_SNAKE_CASE__		: Dict     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , words=SCREAMING_SNAKE_CASE__     , boxes=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(SCREAMING_SNAKE_CASE__     , []					)



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     pipeline(
											    """document-question-answering"""     , model="""tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa"""     , revision="""9977165"""     , )
											SCREAMING_SNAKE_CASE__		: str     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     """What is the invoice number?"""

											SCREAMING_SNAKE_CASE__		: List[str]     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.9944, """answer""": """us-001""", """start""": 16, """end""": 16},
											        {"""score""": 0.0009, """answer""": """us-001""", """start""": 16, """end""": 16},
											    ]     , )

											SCREAMING_SNAKE_CASE__		: Tuple     =     dqa_pipeline({"""image""": image, """question""": question}     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.9944, """answer""": """us-001""", """start""": 16, """end""": 16},
											        {"""score""": 0.0009, """answer""": """us-001""", """start""": 16, """end""": 16},
											    ]     , )

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     dqa_pipeline(
											    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}]     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        [
											            {"""score""": 0.9944, """answer""": """us-001""", """start""": 16, """end""": 16},
											            {"""score""": 0.0009, """answer""": """us-001""", """start""": 16, """end""": 16},
											        ],
											    ]
											    * 2     , )



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     pipeline(
											    """document-question-answering"""     , model="""tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa"""     , revision="""9977165"""     , max_seq_len=50     , )
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     """What is the invoice number?"""

											SCREAMING_SNAKE_CASE__		: int     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.9974, """answer""": """1110212019""", """start""": 23, """end""": 23},
											        {"""score""": 0.9948, """answer""": """us-001""", """start""": 16, """end""": 16},
											    ]     , )

											SCREAMING_SNAKE_CASE__		: str     =     dqa_pipeline({"""image""": image, """question""": question}     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.9974, """answer""": """1110212019""", """start""": 23, """end""": 23},
											        {"""score""": 0.9948, """answer""": """us-001""", """start""": 16, """end""": 16},
											    ]     , )

											SCREAMING_SNAKE_CASE__		: List[str]     =     dqa_pipeline(
											    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}]     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        [
											            {"""score""": 0.9974, """answer""": """1110212019""", """start""": 23, """end""": 23},
											            {"""score""": 0.9948, """answer""": """us-001""", """start""": 16, """end""": 16},
											        ]
											    ]
											    * 2     , )



				@slow
				@require_torch
				@require_pytesseract
				@require_vision
				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     AutoTokenizer.from_pretrained(
											    """impira/layoutlm-document-qa"""     , revision="""3dc6de3"""     , add_prefix_space=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     pipeline(
											    """document-question-answering"""     , model="""impira/layoutlm-document-qa"""     , tokenizer=SCREAMING_SNAKE_CASE__     , revision="""3dc6de3"""     , )
											SCREAMING_SNAKE_CASE__		: List[str]     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Any     =     """What is the invoice number?"""

											SCREAMING_SNAKE_CASE__		: int     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.4251, """answer""": """us-001""", """start""": 16, """end""": 16},
											        {"""score""": 0.0819, """answer""": """1110212019""", """start""": 23, """end""": 23},
											    ]     , )

											SCREAMING_SNAKE_CASE__		: str     =     dqa_pipeline({"""image""": image, """question""": question}     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.4251, """answer""": """us-001""", """start""": 16, """end""": 16},
											        {"""score""": 0.0819, """answer""": """1110212019""", """start""": 23, """end""": 23},
											    ]     , )

											SCREAMING_SNAKE_CASE__		: Dict     =     dqa_pipeline(
											    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}]     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        [
											            {"""score""": 0.4251, """answer""": """us-001""", """start""": 16, """end""": 16},
											            {"""score""": 0.0819, """answer""": """1110212019""", """start""": 23, """end""": 23},
											        ]
											    ]
											    * 2     , )

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     list(zip(*apply_tesseract(load_image(SCREAMING_SNAKE_CASE__					)     , SCREAMING_SNAKE_CASE__     , """"""					)					)					)

											# This model should also work if `image` is set to None
											SCREAMING_SNAKE_CASE__		: Dict     =     dqa_pipeline({"""image""": None, """word_boxes""": word_boxes, """question""": question}     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.4251, """answer""": """us-001""", """start""": 16, """end""": 16},
											        {"""score""": 0.0819, """answer""": """1110212019""", """start""": 23, """end""": 23},
											    ]     , )



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Any     =     AutoTokenizer.from_pretrained(
											    """impira/layoutlm-document-qa"""     , revision="""3dc6de3"""     , add_prefix_space=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     pipeline(
											    """document-question-answering"""     , model="""impira/layoutlm-document-qa"""     , tokenizer=SCREAMING_SNAKE_CASE__     , revision="""3dc6de3"""     , max_seq_len=50     , )
											SCREAMING_SNAKE_CASE__		: str     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: Dict     =     """What is the invoice number?"""

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.9999, """answer""": """us-001""", """start""": 16, """end""": 16},
											        {"""score""": 0.9998, """answer""": """us-001""", """start""": 16, """end""": 16},
											    ]     , )

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     dqa_pipeline(
											    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}]     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        [
											            {"""score""": 0.9999, """answer""": """us-001""", """start""": 16, """end""": 16},
											            {"""score""": 0.9998, """answer""": """us-001""", """start""": 16, """end""": 16},
											        ]
											    ]
											    * 2     , )

											SCREAMING_SNAKE_CASE__		: Any     =     list(zip(*apply_tesseract(load_image(SCREAMING_SNAKE_CASE__					)     , SCREAMING_SNAKE_CASE__     , """"""					)					)					)

											# This model should also work if `image` is set to None
											SCREAMING_SNAKE_CASE__		: List[Any]     =     dqa_pipeline({"""image""": None, """word_boxes""": word_boxes, """question""": question}     , top_k=2					)
											self.assertEqual(
											    nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [
											        {"""score""": 0.9999, """answer""": """us-001""", """start""": 16, """end""": 16},
											        {"""score""": 0.9998, """answer""": """us-001""", """start""": 16, """end""": 16},
											    ]     , )



				@slow
				@require_torch
				def 			__magic_name__					(self					)      ->	Optional[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     pipeline(
											    """document-question-answering"""     , model="""naver-clova-ix/donut-base-finetuned-docvqa"""     , tokenizer=AutoTokenizer.from_pretrained("""naver-clova-ix/donut-base-finetuned-docvqa"""					)     , feature_extractor="""naver-clova-ix/donut-base-finetuned-docvqa"""     , )

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     INVOICE_URL
											SCREAMING_SNAKE_CASE__		: List[Any]     =     """What is the invoice number?"""
											SCREAMING_SNAKE_CASE__		: int     =     dqa_pipeline(image=SCREAMING_SNAKE_CASE__     , question=SCREAMING_SNAKE_CASE__     , top_k=2					)
											self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__     , decimals=4					)     , [{"""answer""": """us-001"""}]					)



				@require_tf
				@unittest.skip("""Document question answering not implemented in TF"""					)
				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											pass






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




