


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    :

				"""simple docstring"""







				def __init__(						self				,   a__				,   a__=13				,   a__=7				,   a__=True				,   a__=True				,   a__=True				,   a__=True				,   a__=99				,   a__=32				,   a__=2				,   a__=4				,   a__=37				,   a__="gelu"				,   a__=0.1				,   a__=0.1				,   a__=512				,   a__=16				,   a__=2				,   a__=0.02				,   a__=3				,   a__=4				,   a__=None				,   a__=1000				,   )	->				Tuple:
					A								=				parent
					A								=				batch_size
					A								=				seq_length
					A								=				is_training
					A								=				use_input_mask
					A								=				use_token_type_ids
					A								=				use_labels
					A								=				vocab_size
					A								=				hidden_size
					A								=				num_hidden_layers
					A								=				num_attention_heads
					A								=				intermediate_size
					A								=				hidden_act
					A								=				hidden_dropout_prob
					A								=				attention_probs_dropout_prob
					A								=				max_position_embeddings
					A								=				type_vocab_size
					A								=				type_sequence_label_size
					A								=				initializer_range
					A								=				num_labels
					A								=				num_choices
					A								=				scope
					A								=				range_bbox

				def      _UpperCAmelCase					(						self   )	->				int:
					A								=				ids_tensor([self.batch_size, self.seq_length]				,   self.vocab_size   )

					# convert bbox to numpy since TF does not support item assignment
					A								=				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]:
								A								=				bbox[i, j, 3]
								A								=				bbox[i, j, 1]
								A								=				t
							if bbox[i, j, 2] < bbox[i, j, 0]:
								A								=				bbox[i, j, 2]
								A								=				bbox[i, j, 0]
								A								=				t
					A								=				tf.convert_to_tensor(a__   )

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

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

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

					A								=				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				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__   )	->				Optional[Any]:
					A								=				TFLayoutLMModel(config=a__   )

					A								=				model(a__				,   a__				,   attention_mask=a__				,   token_type_ids=a__   )
					A								=				model(a__				,   a__				,   token_type_ids=a__   )
					A								=				model(a__				,   a__   )
					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				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__   )	->				Dict:
					A								=				TFLayoutLMForMaskedLM(config=a__   )

					A								=				model(a__				,   a__				,   attention_mask=a__				,   token_type_ids=a__				,   labels=a__   )
					self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.seq_length, self.vocab_size)   )

				def      _UpperCAmelCase					(						self				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__   )	->				Tuple:
					A								=				self.num_labels
					A								=				TFLayoutLMForSequenceClassification(config=a__   )

					A								=				model(a__				,   a__				,   attention_mask=a__				,   token_type_ids=a__   )
					self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.num_labels)   )

				def      _UpperCAmelCase					(						self				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__   )	->				str:
					A								=				self.num_labels
					A								=				TFLayoutLMForTokenClassification(config=a__   )

					A								=				model(a__				,   a__				,   attention_mask=a__				,   token_type_ids=a__				,   labels=a__   )
					self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.seq_length, self.num_labels)   )

				def      _UpperCAmelCase					(						self				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__				,   a__   )	->				Union[str, Any]:
					A								=				TFLayoutLMForQuestionAnswering(config=a__   )

					A								=				model(a__				,   a__				,   attention_mask=a__				,   token_type_ids=a__   )
					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:
					A								=				self.prepare_config_and_inputs()
					(
					    (
					    A
					)					,			(
					    A
					)					,			(
					    A
					)					,			(
					    A
					)					,			(
					    A
					)					,			(
					    A
					)					,			(
					    A
					)					,			(
					    A
					)					,			
					)								=				config_and_inputs
					A								=				{
					    """input_ids""": input_ids,
					    """bbox""": bbox,
					    """token_type_ids""": token_type_ids,
					    """attention_mask""": input_mask,
					}
					return config, inputs_dict






@require_tf
class       _UpperCamelCase    (					__snake_case    ,		__snake_case    ,		unittest.TestCase				):

				"""simple docstring"""







				lowerCAmelCase 		= (
				    (
				        TFLayoutLMModel,
				        TFLayoutLMForMaskedLM,
				        TFLayoutLMForTokenClassification,
				        TFLayoutLMForSequenceClassification,
				        TFLayoutLMForQuestionAnswering,
				    )
				    if is_tf_available()
				    else ()
				)
				lowerCAmelCase 		= (
				    {
				        'feature-extraction': TFLayoutLMModel,
				        'fill-mask': TFLayoutLMForMaskedLM,
				        'text-classification': TFLayoutLMForSequenceClassification,
				        'token-classification': TFLayoutLMForTokenClassification,
				        'zero-shot': TFLayoutLMForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				lowerCAmelCase 		= False
				lowerCAmelCase 		= True
				lowerCAmelCase 		= 1_0

				def      _UpperCAmelCase					(						self   )	->				Dict:
					A								=				TFLayoutLMModelTester(self   )
					A								=				ConfigTester(self				,   config_class=a__				,   hidden_size=37   )

				def      _UpperCAmelCase					(						self   )	->				Optional[int]:
					self.config_tester.run_common_tests()

				def      _UpperCAmelCase					(						self   )	->				Any:
					A								=				self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*a__   )

				def      _UpperCAmelCase					(						self   )	->				Union[str, Any]:
					A								=				self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_lm(*a__   )

				def      _UpperCAmelCase					(						self   )	->				Optional[Any]:
					A								=				self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(*a__   )

				def      _UpperCAmelCase					(						self   )	->				List[Any]:
					A								=				self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*a__   )

				def      _UpperCAmelCase					(						self   )	->				List[str]:
					A								=				self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*a__   )

				@slow
				def      _UpperCAmelCase					(						self   )	->				str:
					for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						A								=				TFLayoutLMModel.from_pretrained(a__   )
						self.assertIsNotNone(a__   )

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





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





	"""simple docstring"""







	A								=				tf.convert_to_tensor([[1_01,10_19,10_14,10_16,10_37,1_28_49,47_47,10_04,1_42_46,22_78,54_39,45_24,50_02,29_30,21_93,29_30,43_41,32_08,10_05,10_55,21_71,28_48,1_13_00,35_31,1_02],[1_01,40_70,40_34,70_20,10_24,30_58,10_15,10_13,28_61,10_13,60_70,1_92_74,27_72,62_05,2_78_14,1_61_47,1_61_47,43_43,20_47,1_02_83,1_09_69,1_43_89,10_12,23_38,1_02]]						)  # noqa: E231
	A								=				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
	A								=				tf.convert_to_tensor([[[0,0,0,0],[4_23,2_37,4_40,2_51],[4_27,2_72,4_41,2_87],[4_19,1_15,4_37,1_29],[9_61,8_85,9_92,9_12],[2_56,38,3_30,58],[2_56,38,3_30,58],[3_36,42,3_53,57],[3_60,39,4_01,56],[3_60,39,4_01,56],[4_11,39,4_71,59],[4_79,41,5_28,59],[5_33,39,6_30,60],[67,1_13,1_34,1_31],[1_41,1_15,2_09,1_32],[68,1_49,1_33,1_66],[1_41,1_49,1_87,1_64],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[2_95,1_48,3_49,1_65],[4_41,1_49,4_92,1_66],[4_97,1_49,5_46,1_64],[64,2_01,1_25,2_18],[10_00,10_00,10_00,10_00]],[[0,0,0,0],[6_62,1_50,7_54,1_66],[6_65,1_99,7_42,2_11],[5_19,2_13,5_54,2_28],[5_19,2_13,5_54,2_28],[1_34,4_33,1_87,4_54],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[3_14,4_69,3_76,4_82],[5_04,6_84,5_82,7_06],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[6_10,7_49,6_52,7_65],[1_30,6_59,1_68,6_72],[1_76,6_57,2_37,6_72],[2_38,6_57,3_12,6_72],[4_43,6_53,6_28,6_72],[4_43,6_53,6_28,6_72],[7_16,3_01,8_25,3_17],[10_00,10_00,10_00,10_00]]]						)  # noqa: E231
	A								=				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)
	A								=				tf.convert_to_tensor([[-1_00,10,10,10,9,1,-1_00,7,7,-1_00,7,7,4,2,5,2,8,8,-1_00,-1_00,5,0,3,2,-1_00],[-1_00,12,12,12,-1_00,12,10,-1_00,-1_00,-1_00,-1_00,10,12,9,-1_00,-1_00,-1_00,10,10,10,9,12,-1_00,10,-1_00]]						)  # noqa: E231
	# fmt: on

	return input_ids, attention_mask, bbox, token_type_ids, labels






@require_tf
class       _UpperCamelCase    (					unittest.TestCase				):

				"""simple docstring"""







				@slow
				def      _UpperCAmelCase					(						self   )	->				int:
					A								=				TFLayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""   )

					A					,			A					,			A					,			A					,			A								=				prepare_layoutlm_batch_inputs()

					# forward pass
					A								=				model(input_ids=a__				,   bbox=a__				,   attention_mask=a__				,   token_type_ids=a__   )

					# test the sequence output on [0, :3, :3]
					A								=				tf.convert_to_tensor(
					    [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]]				,   )

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

					# test the pooled output on [1, :3]
					A								=				tf.convert_to_tensor([-0.65_80, -0.02_14, 0.85_52]   )

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

				@slow
				def      _UpperCAmelCase					(						self   )	->				Dict:
					# initialize model with randomly initialized sequence classification head
					A								=				TFLayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""				,   num_labels=2   )

					A					,			A					,			A					,			A					,			A								=				prepare_layoutlm_batch_inputs()

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

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

					# test the shape of the logits
					A								=				outputs.logits
					A								=				(2, 2)
					self.assertEqual(logits.shape				,   a__   )

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

					A					,			A					,			A					,			A					,			A								=				prepare_layoutlm_batch_inputs()

					# forward pass
					A								=				model(
					    input_ids=a__				,   bbox=a__				,   attention_mask=a__				,   token_type_ids=a__				,   labels=a__   )

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

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

					A					,			A					,			A					,			A					,			A								=				prepare_layoutlm_batch_inputs()

					# forward pass
					A								=				model(input_ids=a__				,   bbox=a__				,   attention_mask=a__				,   token_type_ids=a__   )

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







from __future__ import annotations

from typing import Any






class       _UpperCamelCase    :

				"""simple docstring"""







				def __init__(						self				,   a__				,   a__				,   a__ = 0   )	->				None:
					A					,			A								=				row, column
					A								=				[[default_value for c in range(a__   )] for r in range(a__   )]

				def __str__(						self   )	->				str:
					A								=				f'Matrix consist of {self.row} rows and {self.column} columns\n'

					# Make string identifier
					A								=				0
					for row_vector in self.array:
						for obj in row_vector:
							A								=				max(a__				,   len(str(a__   )   )   )
					A								=				f'%{max_element_length}s'

					# Make string and return
					def single_line(a__   ) -> str:
						nonlocal string_format_identifier
						A								=				"""["""
						line += ", ".join(string_format_identifier % (obj,) for obj in row_vector   )
						line += "]"
						return line

					s += "\n".join(single_line(a__   ) for row_vector in self.array   )
					return s

				def __repr__(						self   )	->				str:
					return str(self   )

				def      _UpperCAmelCase					(						self				,   a__   )	->				bool:
					if not (isinstance(a__				,   (list, tuple)   ) and len(a__   ) == 2):
						return False
					elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
						return False
					else:
						return True

				def __getitem__(						self				,   a__   )	->				Any:
					assert self.validate_indicies(a__   )
					return self.array[loc[0]][loc[1]]

				def __setitem__(						self				,   a__				,   a__   )	->				None:
					assert self.validate_indicies(a__   )
					A								=				value

				def __add__(						self				,   a__   )	->				Matrix:
					assert isinstance(a__				,   a__   )
					assert self.row == another.row and self.column == another.column

					# Add
					A								=				Matrix(self.row				,   self.column   )
					for r in range(self.row   ):
						for c in range(self.column   ):
							A								=				self[r, c] + another[r, c]
					return result

				def __neg__(						self   )	->				Matrix:
					A								=				Matrix(self.row				,   self.column   )
					for r in range(self.row   ):
						for c in range(self.column   ):
							A								=				-self[r, c]
					return result

				def __sub__(						self				,   a__   )	->				Matrix:
					return self + (-another)

				def __mul__(						self				,   a__   )	->				Matrix:

					if isinstance(a__				,   (int, float)   ):  # Scalar multiplication
						A								=				Matrix(self.row				,   self.column   )
						for r in range(self.row   ):
							for c in range(self.column   ):
								A								=				self[r, c] * another
						return result
					elif isinstance(a__				,   a__   ):  # Matrix multiplication
						assert self.column == another.row
						A								=				Matrix(self.row				,   another.column   )
						for r in range(self.row   ):
							for c in range(another.column   ):
								for i in range(self.column   ):
									result[r, c] += self[r, i] * another[i, c]
						return result
					else:
						A								=				f'Unsupported type given for another ({type(a__   )})'
						raise TypeError(a__   )

				def      _UpperCAmelCase					(						self   )	->				Matrix:
					A								=				Matrix(self.column				,   self.row   )
					for r in range(self.row   ):
						for c in range(self.column   ):
							A								=				self[r, c]
					return result

				def      _UpperCAmelCase					(						self				,   a__				,   a__   )	->				Any:
					assert isinstance(a__				,   a__   ) and isinstance(a__				,   a__   )
					assert self.row == self.column == u.row == v.row  # u, v should be column vector
					assert u.column == v.column == 1  # u, v should be column vector

					# Calculate
					A								=				v.transpose()
					A								=				(v_t * self * u)[0, 0] + 1
					if numerator_factor == 0:
						return None  # It's not invertable
					return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))


# Testing
if __name__ == "__main__":





				def   _lowerCAmelCase				(   ) ->   None:





					"""simple docstring"""







					A								=				Matrix(3							,					3							,					0						)
					for i in range(3						):
						A								=				1
					print(f'a^(-1) is {ainv}'						)
					# u, v
					A								=				Matrix(3							,					1							,					0						)
					A					,			A					,			A								=				1, 2, -3
					A								=				Matrix(3							,					1							,					0						)
					A					,			A					,			A								=				4, -2, 5
					print(f'u is {u}'						)
					print(f'v is {v}'						)
					print(f'uv^T is {u * v.transpose()}'						)
					# Sherman Morrison
					print(f'(a + uv^T)^(-1) is {ainv.sherman_morrison(UpperCamelCase__							,					UpperCamelCase__						)}'						)





				def   _lowerCAmelCase				(   ) ->   None:





					"""simple docstring"""







					import doctest

					doctest.testmod()
				testa()



