


from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
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.models.layoutlm.modeling_tf_layoutlm import (
		    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFLayoutLMForMaskedLM,
		    TFLayoutLMForQuestionAnswering,
		    TFLayoutLMForSequenceClassification,
		    TFLayoutLMForTokenClassification,
		    TFLayoutLMModel,
		)

class 		__a				:
		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=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=512      ,   _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      ,   _SCREAMING_SNAKE_CASE=1000      ,   )			->	int:




									"""simple docstring"""





									_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					=      range_bbox
		def      UpperCAmelCase__    (      self						)			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      ids_tensor([self.batch_size, self.seq_length]      ,   self.vocab_size						)

									# convert bbox to numpy since TF does not support item assignment
									_UpperCAmelCase					=      ids_tensor([self.batch_size, self.seq_length, 4]      ,   self.range_bbox						).numpy()
									# Ensure that bbox is legal
									for i in range(bbox.shape[0]						):
																for j in range(bbox.shape[1]						):
																							if bbox[i, j, 3] < bbox[i, j, 1]:
																														_UpperCAmelCase					=      bbox[i, j, 3]
																														_UpperCAmelCase					=      bbox[i, j, 1]
																														_UpperCAmelCase					=      t
																							if bbox[i, j, 2] < bbox[i, j, 0]:
																														_UpperCAmelCase					=      bbox[i, j, 2]
																														_UpperCAmelCase					=      bbox[i, j, 0]
																														_UpperCAmelCase					=      t
									_UpperCAmelCase					=      tf.convert_to_tensor(_SCREAMING_SNAKE_CASE						)

									_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					=      LayoutLMConfig(
									    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      ,   )

									return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _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"""





									_UpperCAmelCase					=      TFLayoutLMModel(config=_SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   _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      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	Any:




									"""simple docstring"""





									_UpperCAmelCase					=      TFLayoutLMForMaskedLM(config=_SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE      ,   labels=_SCREAMING_SNAKE_CASE						)
									self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.vocab_size)						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      self.num_labels
									_UpperCAmelCase					=      TFLayoutLMForSequenceClassification(config=_SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE						)
									self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_labels)						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	str:




									"""simple docstring"""





									_UpperCAmelCase					=      self.num_labels
									_UpperCAmelCase					=      TFLayoutLMForTokenClassification(config=_SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE      ,   labels=_SCREAMING_SNAKE_CASE						)
									self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.num_labels)						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	Any:




									"""simple docstring"""





									_UpperCAmelCase					=      TFLayoutLMForQuestionAnswering(config=_SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_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      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									_UpperCAmelCase					=      self.prepare_config_and_inputs()
									(
									    (
									    _UpperCAmelCase
									)		,	(
									    _UpperCAmelCase
									)		,	(
									    _UpperCAmelCase
									)		,	(
									    _UpperCAmelCase
									)		,	(
									    _UpperCAmelCase
									)		,	(
									    _UpperCAmelCase
									)		,	(
									    _UpperCAmelCase
									)		,	(
									    _UpperCAmelCase
									)		,	
									)					=      config_and_inputs
									_UpperCAmelCase					=      {
									    'input_ids': input_ids,
									    'bbox': bbox,
									    'token_type_ids': token_type_ids,
									    'attention_mask': input_mask,
									}
									return config, inputs_dict



@require_tf
class 		__a				(    UpperCAmelCase   ,				UpperCAmelCase   ,				unittest.TestCase      ):
		_a     :  List[str]           =     (
		    (
		        TFLayoutLMModel,
		        TFLayoutLMForMaskedLM,
		        TFLayoutLMForTokenClassification,
		        TFLayoutLMForSequenceClassification,
		        TFLayoutLMForQuestionAnswering,
		    )
		    if is_tf_available()
		    else ()
		)
		_a     :  Any           =     (
		    {
		        'feature-extraction': TFLayoutLMModel,
		        'fill-mask': TFLayoutLMForMaskedLM,
		        'text-classification': TFLayoutLMForSequenceClassification,
		        'token-classification': TFLayoutLMForTokenClassification,
		        'zero-shot': TFLayoutLMForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)
		_a     :  Optional[int]           =     False
		_a     :  List[Any]           =     True
		_a     :  Tuple           =     10
		def      UpperCAmelCase__    (      self						)			->	List[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      TFLayoutLMModelTester(self						)
									_UpperCAmelCase					=      ConfigTester(self      ,   config_class=_SCREAMING_SNAKE_CASE      ,   hidden_size=37						)
		def      UpperCAmelCase__    (      self						)			->	Optional[Any]:




									"""simple docstring"""





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




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	Dict:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	Union[str, Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	Any:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*_SCREAMING_SNAKE_CASE						)
		@slow
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCAmelCase					=      TFLayoutLMModel.from_pretrained(_SCREAMING_SNAKE_CASE						)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE						)






		@unittest.skip('Onnx compliancy broke with TF 2.10'						)
		def      UpperCAmelCase__    (      self						)			->	Any:




									"""simple docstring"""





									pass



def 	lowerCAmelCase__			(      )  ->		List[str]:


							'''simple docstring'''





							_UpperCAmelCase					=      tf.convert_to_tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]]	)  # noqa: E231
							_UpperCAmelCase					=      tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]	)  # noqa: E231
							_UpperCAmelCase					=      tf.convert_to_tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]]	)  # noqa: E231
							_UpperCAmelCase					=      tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]	)  # noqa: E231
							# these are sequence labels (i.e. at the token level)
							_UpperCAmelCase					=      tf.convert_to_tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]]	)  # noqa: E231
							# fmt: on

							return input_ids, attention_mask, bbox, token_type_ids, labels







@require_tf
class 		__a				(    unittest.TestCase      ):
		@slow
		def      UpperCAmelCase__    (      self						)			->	Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=      TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'						)

									_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase					=      prepare_layoutlm_batch_inputs()

									# forward pass
									_UpperCAmelCase					=      model(input_ids=_SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE						)

									# test the sequence output on [0, :3, :3]
									_UpperCAmelCase					=      tf.convert_to_tensor(
									    [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]      ,   )

									self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]      ,   _SCREAMING_SNAKE_CASE      ,   atol=1e-3						)						)

									# test the pooled output on [1, :3]
									_UpperCAmelCase					=      tf.convert_to_tensor([-0.6580, -0.0214, 0.8552]						)

									self.assertTrue(np.allclose(outputs.pooler_output[1, :3]      ,   _SCREAMING_SNAKE_CASE      ,   atol=1e-3						)						)
		@slow
		def      UpperCAmelCase__    (      self						)			->	Dict:




									"""simple docstring"""





									_UpperCAmelCase					=      TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'      ,   num_labels=2						)

									_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase					=      prepare_layoutlm_batch_inputs()

									# forward pass
									_UpperCAmelCase					=      model(
									    input_ids=_SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE      ,   labels=tf.convert_to_tensor([1, 1]						)      ,   )

									# test whether we get a loss as a scalar
									_UpperCAmelCase					=      outputs.loss
									_UpperCAmelCase					=      (2,)
									self.assertEqual(loss.shape      ,   _SCREAMING_SNAKE_CASE						)

									# test the shape of the logits
									_UpperCAmelCase					=      outputs.logits
									_UpperCAmelCase					=      (2, 2)
									self.assertEqual(logits.shape      ,   _SCREAMING_SNAKE_CASE						)
		@slow
		def      UpperCAmelCase__    (      self						)			->	Optional[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'      ,   num_labels=13						)

									_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase					=      prepare_layoutlm_batch_inputs()

									# forward pass
									_UpperCAmelCase					=      model(
									    input_ids=_SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE      ,   labels=_SCREAMING_SNAKE_CASE						)

									# test the shape of the logits
									_UpperCAmelCase					=      outputs.logits
									_UpperCAmelCase					=      tf.convert_to_tensor((2, 25, 13)						)
									self.assertEqual(logits.shape      ,   _SCREAMING_SNAKE_CASE						)






		@slow
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									_UpperCAmelCase					=      TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'						)

									_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase		,	_UpperCAmelCase					=      prepare_layoutlm_batch_inputs()

									# forward pass
									_UpperCAmelCase					=      model(input_ids=_SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE						)

									# test the shape of the logits
									_UpperCAmelCase					=      tf.convert_to_tensor((2, 25)						)
									self.assertEqual(outputs.start_logits.shape      ,   _SCREAMING_SNAKE_CASE						)
									self.assertEqual(outputs.end_logits.shape      ,   _SCREAMING_SNAKE_CASE						)




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase__  :List[str]             =							{
    '''configuration_x_clip''': [
        '''XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''XCLIPConfig''',
        '''XCLIPTextConfig''',
        '''XCLIPVisionConfig''',
    ],
    '''processing_x_clip''': ['''XCLIPProcessor'''],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCAmelCase__  :Any             =							[
		    '''XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''XCLIPModel''',
		    '''XCLIPPreTrainedModel''',
		    '''XCLIPTextModel''',
		    '''XCLIPVisionModel''',
		]

if TYPE_CHECKING:
		from .configuration_x_clip import (
		    XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    XCLIPConfig,
		    XCLIPTextConfig,
		    XCLIPVisionConfig,
		)
		from .processing_x_clip import XCLIPProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_x_clip import (
				    XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    XCLIPModel,
				    XCLIPPreTrainedModel,
				    XCLIPTextModel,
				    XCLIPVisionModel,
				)

else:
		import sys

		lowerCAmelCase__  :str             =							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
