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        UpperCamelCase						:





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





						def        A_							(self						)				->				Any:
												UpperCamelCase_		:							List[str]  =		ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size						)

												# convert bbox to numpy since TF does not support item assignment
												UpperCamelCase_		:							Dict  =		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_		:							int  =		bbox[i, j, 3]
																														UpperCamelCase_		:							List[Any]  =		bbox[i, j, 1]
																														UpperCamelCase_		:							Optional[Any]  =		t
																								if bbox[i, j, 2] < bbox[i, j, 0]:
																														UpperCamelCase_		:							Optional[Any]  =		bbox[i, j, 2]
																														UpperCamelCase_		:							Dict  =		bbox[i, j, 0]
																														UpperCamelCase_		:							Optional[int]  =		t
												UpperCamelCase_		:							Tuple  =		tf.convert_to_tensor(__UpperCamelCase						)

												UpperCamelCase_		:							Union[str, Any]  =		None
												if self.use_input_mask:
																		UpperCamelCase_		:							Any  =		random_attention_mask([self.batch_size, self.seq_length]						)

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

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

												UpperCamelCase_		:							Optional[Any]  =		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        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				Tuple:
												UpperCamelCase_		:							Optional[int]  =		TFLayoutLMModel(config=__UpperCamelCase						)

												UpperCamelCase_		:							Optional[int]  =		model(__UpperCamelCase			,     __UpperCamelCase			,     attention_mask=__UpperCamelCase			,     token_type_ids=__UpperCamelCase						)
												UpperCamelCase_		:							Any  =		model(__UpperCamelCase			,     __UpperCamelCase			,     token_type_ids=__UpperCamelCase						)
												UpperCamelCase_		:							Tuple  =		model(__UpperCamelCase			,     __UpperCamelCase						)
												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        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				List[Any]:
												UpperCamelCase_		:							str  =		TFLayoutLMForMaskedLM(config=__UpperCamelCase						)

												UpperCamelCase_		:							Optional[Any]  =		model(__UpperCamelCase			,     __UpperCamelCase			,     attention_mask=__UpperCamelCase			,     token_type_ids=__UpperCamelCase			,     labels=__UpperCamelCase						)
												self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)						)





						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				Dict:
												UpperCamelCase_		:							Dict  =		self.num_labels
												UpperCamelCase_		:							str  =		TFLayoutLMForSequenceClassification(config=__UpperCamelCase						)

												UpperCamelCase_		:							Optional[Any]  =		model(__UpperCamelCase			,     __UpperCamelCase			,     attention_mask=__UpperCamelCase			,     token_type_ids=__UpperCamelCase						)
												self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)						)





						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				Tuple:
												UpperCamelCase_		:							Dict  =		self.num_labels
												UpperCamelCase_		:							Optional[int]  =		TFLayoutLMForTokenClassification(config=__UpperCamelCase						)

												UpperCamelCase_		:							Dict  =		model(__UpperCamelCase			,     __UpperCamelCase			,     attention_mask=__UpperCamelCase			,     token_type_ids=__UpperCamelCase			,     labels=__UpperCamelCase						)
												self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.num_labels)						)





						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				Dict:
												UpperCamelCase_		:							Tuple  =		TFLayoutLMForQuestionAnswering(config=__UpperCamelCase						)

												UpperCamelCase_		:							Union[str, Any]  =		model(__UpperCamelCase			,     __UpperCamelCase			,     attention_mask=__UpperCamelCase			,     token_type_ids=__UpperCamelCase						)
												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        A_							(self						)				->				Dict:
												UpperCamelCase_		:							List[Any]  =		self.prepare_config_and_inputs()
												(
												    (
												    UpperCamelCase_
												),(
												    UpperCamelCase_
												),(
												    UpperCamelCase_
												),(
												    UpperCamelCase_
												),(
												    UpperCamelCase_
												),(
												    UpperCamelCase_
												),(
												    UpperCamelCase_
												),(
												    UpperCamelCase_
												),
												)		:							Optional[int]  =		config_and_inputs
												UpperCamelCase_		:							Union[str, Any]  =		{
												    """input_ids""": input_ids,
												    """bbox""": bbox,
												    """token_type_ids""": token_type_ids,
												    """attention_mask""": input_mask,
												}
												return config, inputs_dict


@require_tf
class        UpperCamelCase						(				__a	,	__a	,	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[str]      =			True
						a__		:Tuple      =			10





						def        A_							(self						)				->				Optional[int]:
												UpperCamelCase_		:							int  =		TFLayoutLMModelTester(self						)
												UpperCamelCase_		:							str  =		ConfigTester(self			,     config_class=__UpperCamelCase			,     hidden_size=37						)





						def        A_							(self						)				->				List[str]:
												self.config_tester.run_common_tests()





						def        A_							(self						)				->				List[str]:
												UpperCamelCase_		:							Optional[Any]  =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__UpperCamelCase						)





						def        A_							(self						)				->				Any:
												UpperCamelCase_		:							Tuple  =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase						)





						def        A_							(self						)				->				List[str]:
												UpperCamelCase_		:							Optional[Any]  =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase						)





						def        A_							(self						)				->				Tuple:
												UpperCamelCase_		:							Dict  =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase						)





						def        A_							(self						)				->				str:
												UpperCamelCase_		:							List[str]  =		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase						)





						@slow
						def        A_							(self						)				->				str:
												for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		UpperCamelCase_		:							List[Any]  =		TFLayoutLMModel.from_pretrained(__UpperCamelCase						)
																		self.assertIsNotNone(__UpperCamelCase						)





						@unittest.skip("""Onnx compliancy broke with TF 2.10"""						)
						def        A_							(self						)				->				str:
												pass






def     lowerCAmelCase_			(   ):
						# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
						# fmt: off
						UpperCamelCase_		:							List[Any]  =		tf.convert_to_tensor([[101,1019,1014,1016,1037,1_2849,4747,1004,1_4246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,1_1300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,1_9274,2772,6205,2_7814,1_6147,1_6147,4343,2047,1_0283,1_0969,1_4389,1012,2338,102]]			)  # noqa: E231
						UpperCamelCase_		:							Any  =		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_		:							Tuple  =		tf.convert_to_tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1000,1000,1000,1000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1000,1000,1000,1000]]]			)  # noqa: E231
						UpperCamelCase_		:							Any  =		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_		:							List[Any]  =		tf.convert_to_tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]			)  # noqa: E231
						# fmt: on

						return input_ids, attention_mask, bbox, token_type_ids, labels







@require_tf
class        UpperCamelCase						(				unittest.TestCase				):





						@slow
						def        A_							(self						)				->				Any:
												UpperCamelCase_		:							Optional[int]  =		TFLayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""						)

												UpperCamelCase_,UpperCamelCase_,UpperCamelCase_,UpperCamelCase_,UpperCamelCase_		:							Optional[Any]  =		prepare_layoutlm_batch_inputs()

												# forward pass
												UpperCamelCase_		:							List[Any]  =		model(input_ids=__UpperCamelCase			,     bbox=__UpperCamelCase			,     attention_mask=__UpperCamelCase			,     token_type_ids=__UpperCamelCase						)

												# test the sequence output on [0, :3, :3]
												UpperCamelCase_		:							List[Any]  =		tf.convert_to_tensor(
												    [[0.1_785, -0.1_947, -0.0_425], [-0.3_254, -0.2_807, 0.2_553], [-0.5_391, -0.3_322, 0.3_364]]			,     )

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

												# test the pooled output on [1, :3]
												UpperCamelCase_		:							List[str]  =		tf.convert_to_tensor([-0.6_580, -0.0_214, 0.8_552]						)

												self.assertTrue(np.allclose(outputs.pooler_output[1, :3]			,     __UpperCamelCase			,     atol=1E-3						)						)





						@slow
						def        A_							(self						)				->				Optional[Any]:
												# initialize model with randomly initialized sequence classification head
												UpperCamelCase_		:							Optional[Any]  =		TFLayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""			,     num_labels=2						)

												UpperCamelCase_,UpperCamelCase_,UpperCamelCase_,UpperCamelCase_,UpperCamelCase_		:							str  =		prepare_layoutlm_batch_inputs()

												# forward pass
												UpperCamelCase_		:							Optional[Any]  =		model(
												    input_ids=__UpperCamelCase			,     bbox=__UpperCamelCase			,     attention_mask=__UpperCamelCase			,     token_type_ids=__UpperCamelCase			,     labels=tf.convert_to_tensor([1, 1]						)			,     )

												# test whether we get a loss as a scalar
												UpperCamelCase_		:							Optional[Any]  =		outputs.loss
												UpperCamelCase_		:							str  =		(2,)
												self.assertEqual(loss.shape			,     __UpperCamelCase						)

												# test the shape of the logits
												UpperCamelCase_		:							Optional[Any]  =		outputs.logits
												UpperCamelCase_		:							List[Any]  =		(2, 2)
												self.assertEqual(logits.shape			,     __UpperCamelCase						)





						@slow
						def        A_							(self						)				->				str:
												# initialize model with randomly initialized token classification head
												UpperCamelCase_		:							str  =		TFLayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""			,     num_labels=13						)

												UpperCamelCase_,UpperCamelCase_,UpperCamelCase_,UpperCamelCase_,UpperCamelCase_		:							List[Any]  =		prepare_layoutlm_batch_inputs()

												# forward pass
												UpperCamelCase_		:							List[str]  =		model(
												    input_ids=__UpperCamelCase			,     bbox=__UpperCamelCase			,     attention_mask=__UpperCamelCase			,     token_type_ids=__UpperCamelCase			,     labels=__UpperCamelCase						)

												# test the shape of the logits
												UpperCamelCase_		:							Tuple  =		outputs.logits
												UpperCamelCase_		:							Optional[int]  =		tf.convert_to_tensor((2, 25, 13)						)
												self.assertEqual(logits.shape			,     __UpperCamelCase						)





						@slow
						def        A_							(self						)				->				Optional[Any]:
												# initialize model with randomly initialized token classification head
												UpperCamelCase_		:							Any  =		TFLayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""						)

												UpperCamelCase_,UpperCamelCase_,UpperCamelCase_,UpperCamelCase_,UpperCamelCase_		:							str  =		prepare_layoutlm_batch_inputs()

												# forward pass
												UpperCamelCase_		:							str  =		model(input_ids=__UpperCamelCase			,     bbox=__UpperCamelCase			,     attention_mask=__UpperCamelCase			,     token_type_ids=__UpperCamelCase						)

												# test the shape of the logits
												UpperCamelCase_		:							Any  =		tf.convert_to_tensor((2, 25)						)
												self.assertEqual(outputs.start_logits.shape			,     __UpperCamelCase						)
												self.assertEqual(outputs.end_logits.shape			,     __UpperCamelCase						)







import numpy as np






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				np.array			):
						return (2 / (1 + np.exp(-2 * vector			))) - 1


if __name__ == "__main__":
	import doctest

	doctest.testmod()






