



import unittest

from transformers import LayoutLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    LayoutLMForMaskedLM,
		    LayoutLMForQuestionAnswering,
		    LayoutLMForSequenceClassification,
		    LayoutLMForTokenClassification,
		    LayoutLMModel,
		)


class 	a__       :


					"""simple docstring"""



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

					def 				__UpperCAmelCase		(		self     :Tuple    ):
										lowercase						   =       ids_tensor([self.batch_size, self.seq_length]      ,  self.vocab_size    )

										lowercase						   =       ids_tensor([self.batch_size, self.seq_length, 4]      ,  self.range_bbox    )
										# 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]:
																									lowercase						   =       bbox[i, j, 3]
																									lowercase						   =       bbox[i, j, 1]
																									lowercase						   =       t
																				if bbox[i, j, 2] < bbox[i, j, 0]:
																									lowercase						   =       bbox[i, j, 2]
																									lowercase						   =       bbox[i, j, 0]
																									lowercase						   =       t

										lowercase						   =       None
										if self.use_input_mask:
															lowercase						   =       ids_tensor([self.batch_size, self.seq_length]      ,  vocab_size=2    )

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

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

										lowercase						   =       self.get_config()

										return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

					def 				__UpperCAmelCase		(		self     :str    ):
										return 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      ,  )

					def 				__UpperCAmelCase		(		self     :Dict      ,  lowercase__     :List[Any]      ,  lowercase__     :Union[str, Any]      ,  lowercase__     :int      ,  lowercase__     :List[Any]      ,  lowercase__     :Optional[int]      ,  lowercase__     :Dict      ,  lowercase__     :Optional[int]      ,  lowercase__     :List[str]    ):
										lowercase						   =       LayoutLMModel(config=_lowercase    )
										model.to(_lowercase    )
										model.eval()
										lowercase						   =       model(_lowercase      ,  _lowercase      ,  attention_mask=_lowercase      ,  token_type_ids=_lowercase    )
										lowercase						   =       model(_lowercase      ,  _lowercase      ,  token_type_ids=_lowercase    )
										lowercase						   =       model(_lowercase      ,  _lowercase    )
										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     :List[str]      ,  lowercase__     :Optional[int]      ,  lowercase__     :Tuple      ,  lowercase__     :Dict      ,  lowercase__     :int      ,  lowercase__     :Tuple      ,  lowercase__     :int      ,  lowercase__     :Optional[int]      ,  lowercase__     :Optional[int]    ):
										lowercase						   =       LayoutLMForMaskedLM(config=_lowercase    )
										model.to(_lowercase    )
										model.eval()
										lowercase						   =       model(_lowercase      ,  _lowercase      ,  attention_mask=_lowercase      ,  token_type_ids=_lowercase      ,  labels=_lowercase    )
										self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.vocab_size)    )

					def 				__UpperCAmelCase		(		self     :Union[str, Any]      ,  lowercase__     :Optional[Any]      ,  lowercase__     :Union[str, Any]      ,  lowercase__     :Dict      ,  lowercase__     :Tuple      ,  lowercase__     :List[Any]      ,  lowercase__     :str      ,  lowercase__     :Optional[int]      ,  lowercase__     :str    ):
										lowercase						   =       self.num_labels
										lowercase						   =       LayoutLMForSequenceClassification(_lowercase    )
										model.to(_lowercase    )
										model.eval()
										lowercase						   =       model(
										    _lowercase      ,  _lowercase      ,  attention_mask=_lowercase      ,  token_type_ids=_lowercase      ,  labels=_lowercase    )
										self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_labels)    )

					def 				__UpperCAmelCase		(		self     :Dict      ,  lowercase__     :Dict      ,  lowercase__     :Any      ,  lowercase__     :Union[str, Any]      ,  lowercase__     :int      ,  lowercase__     :List[str]      ,  lowercase__     :Optional[Any]      ,  lowercase__     :Any      ,  lowercase__     :int    ):
										lowercase						   =       self.num_labels
										lowercase						   =       LayoutLMForTokenClassification(config=_lowercase    )
										model.to(_lowercase    )
										model.eval()
										lowercase						   =       model(_lowercase      ,  _lowercase      ,  attention_mask=_lowercase      ,  token_type_ids=_lowercase      ,  labels=_lowercase    )
										self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.num_labels)    )

					def 				__UpperCAmelCase		(		self     :List[Any]      ,  lowercase__     :Dict      ,  lowercase__     :Union[str, Any]      ,  lowercase__     :Tuple      ,  lowercase__     :Union[str, Any]      ,  lowercase__     :Optional[int]      ,  lowercase__     :Tuple      ,  lowercase__     :Optional[int]      ,  lowercase__     :Union[str, Any]    ):
										lowercase						   =       LayoutLMForQuestionAnswering(config=_lowercase    )
										model.to(_lowercase    )
										model.eval()
										lowercase						   =       model(
										    _lowercase      ,  bbox=_lowercase      ,  attention_mask=_lowercase      ,  token_type_ids=_lowercase      ,  start_positions=_lowercase      ,  end_positions=_lowercase      ,  )
										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    ):
										lowercase						   =       self.prepare_config_and_inputs()
										(
										    (
										    lowercase   
										)   ,      (
										    lowercase   
										)   ,      (
										    lowercase   
										)   ,      (
										    lowercase   
										)   ,      (
										    lowercase   
										)   ,      (
										    lowercase   
										)   ,      (
										    lowercase   
										)   ,      (
										    lowercase   
										)   ,         
										)						   =       config_and_inputs
										lowercase						   =       {
										    'input_ids': input_ids,
										    'bbox': bbox,
										    'token_type_ids': token_type_ids,
										    'attention_mask': input_mask,
										}
										return config, inputs_dict




@require_torch
class 	a__       (       __lowerCamelCase  ,			__lowerCamelCase  ,			unittest.TestCase       ):


					"""simple docstring"""



					A__  :				Optional[Any]					 =				(
					    (
					        LayoutLMModel,
					        LayoutLMForMaskedLM,
					        LayoutLMForSequenceClassification,
					        LayoutLMForTokenClassification,
					        LayoutLMForQuestionAnswering,
					    )
					    if is_torch_available()
					    else None
					)
					A__  :				Dict					 =				(
					    {
					        '''document-question-answering''': LayoutLMForQuestionAnswering,
					        '''feature-extraction''': LayoutLMModel,
					        '''fill-mask''': LayoutLMForMaskedLM,
					        '''text-classification''': LayoutLMForSequenceClassification,
					        '''token-classification''': LayoutLMForTokenClassification,
					        '''zero-shot''': LayoutLMForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					A__  :				int					 =				True

					def 				__UpperCAmelCase		(		self     :Union[str, Any]    ):
										lowercase						   =       LayoutLMModelTester(self    )
										lowercase						   =       ConfigTester(self      ,  config_class=_lowercase      ,  hidden_size=37    )

					def 				__UpperCAmelCase		(		self     :str    ):
										self.config_tester.run_common_tests()

					def 				__UpperCAmelCase		(		self     :Any    ):
										lowercase						   =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowercase    )

					def 				__UpperCAmelCase		(		self     :Optional[Any]    ):
										lowercase						   =       self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
															lowercase						   =       type
															self.model_tester.create_and_check_model(*_lowercase    )

					def 				__UpperCAmelCase		(		self     :Optional[int]    ):
										lowercase						   =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*_lowercase    )

					def 				__UpperCAmelCase		(		self     :Optional[Any]    ):
										lowercase						   =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*_lowercase    )

					def 				__UpperCAmelCase		(		self     :List[Any]    ):
										lowercase						   =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*_lowercase    )

					def 				__UpperCAmelCase		(		self     :Union[str, Any]    ):
										lowercase						   =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*_lowercase    )



					@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'    )
					def 				__UpperCAmelCase		(		self     :str    ):
										pass





def 		__snake_case						(    ):
					"""simple docstring"""






					lowercase						   =       torch.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]]       ,			device=UpperCAmelCase__				)  # noqa: E231
					lowercase						   =       torch.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],]       ,			device=UpperCAmelCase__				)  # noqa: E231
					lowercase						   =       torch.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]]]       ,			device=UpperCAmelCase__				)  # noqa: E231
					lowercase						   =       torch.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]]       ,			device=UpperCAmelCase__				)  # noqa: E231
					# these are sequence labels (i.e. at the token level)
					lowercase						   =       torch.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]]       ,			device=UpperCAmelCase__				)  # noqa: E231
					# fmt: on

					return input_ids, attention_mask, bbox, token_type_ids, labels




@require_torch
class 	a__       (       unittest.TestCase       ):


					"""simple docstring"""



					@slow
					def 				__UpperCAmelCase		(		self     :List[Any]    ):
										lowercase						   =       LayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'    ).to(_lowercase    )

										lowercase   ,      lowercase   ,      lowercase   ,      lowercase   ,      lowercase						   =       prepare_layoutlm_batch_inputs()

										# forward pass
										lowercase						   =       model(input_ids=_lowercase      ,  bbox=_lowercase      ,  attention_mask=_lowercase      ,  token_type_ids=_lowercase    )

										# test the sequence output on [0, :3, :3]
										lowercase						   =       torch.tensor(
										    [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]      ,  device=_lowercase      ,  )

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

										# test the pooled output on [1, :3]
										lowercase						   =       torch.tensor([-0.6580, -0.0214, 0.8552]      ,  device=_lowercase    )

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

					@slow
					def 				__UpperCAmelCase		(		self     :Optional[Any]    ):
										lowercase						   =       LayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'      ,  num_labels=2    ).to(
										    _lowercase    )

										lowercase   ,      lowercase   ,      lowercase   ,      lowercase   ,      lowercase						   =       prepare_layoutlm_batch_inputs()

										# forward pass
										lowercase						   =       model(
										    input_ids=_lowercase      ,  bbox=_lowercase      ,  attention_mask=_lowercase      ,  token_type_ids=_lowercase      ,  labels=torch.tensor([1, 1]      ,  device=_lowercase    )      ,  )

										# test whether we get a loss as a scalar
										lowercase						   =       outputs.loss
										lowercase						   =       torch.Size([]    )
										self.assertEqual(loss.shape      ,  _lowercase    )

										# test the shape of the logits
										lowercase						   =       outputs.logits
										lowercase						   =       torch.Size((2, 2)    )
										self.assertEqual(logits.shape      ,  _lowercase    )

					@slow
					def 				__UpperCAmelCase		(		self     :Any    ):
										lowercase						   =       LayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'      ,  num_labels=13    ).to(
										    _lowercase    )

										lowercase   ,      lowercase   ,      lowercase   ,      lowercase   ,      lowercase						   =       prepare_layoutlm_batch_inputs()

										# forward pass
										lowercase						   =       model(
										    input_ids=_lowercase      ,  bbox=_lowercase      ,  attention_mask=_lowercase      ,  token_type_ids=_lowercase      ,  labels=_lowercase    )

										# test the loss calculation to be around 2.65
										# expected_loss = torch.tensor(2.65, device=torch_device)

										# The loss is currently somewhat random and can vary between 0.1-0.3 atol.
										# self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

										# test the shape of the logits
										lowercase						   =       outputs.logits
										lowercase						   =       torch.Size((2, 25, 13)    )
										self.assertEqual(logits.shape      ,  _lowercase    )



					@slow
					def 				__UpperCAmelCase		(		self     :Optional[int]    ):
										lowercase						   =       LayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'    ).to(_lowercase    )

										lowercase   ,      lowercase   ,      lowercase   ,      lowercase   ,      lowercase						   =       prepare_layoutlm_batch_inputs()

										# forward pass
										lowercase						   =       model(input_ids=_lowercase      ,  bbox=_lowercase      ,  attention_mask=_lowercase      ,  token_type_ids=_lowercase    )

										# test the shape of the logits
										lowercase						   =       torch.Size((2, 25)    )
										self.assertEqual(outputs.start_logits.shape      ,  _lowercase    )
										self.assertEqual(outputs.end_logits.shape      ,  _lowercase    )







"""simple docstring"""







import unittest

from transformers import LayoutLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import (
						    LayoutLMForMaskedLM,
						    LayoutLMForQuestionAnswering,
						    LayoutLMForSequenceClassification,
						    LayoutLMForTokenClassification,
						    LayoutLMModel,
						)


class       _lowercase		:

				def __init__(  self							:     Tuple							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     List[Any]=1_3							,     _lowercase							:     Dict=7							,     _lowercase							:     Tuple=True							,     _lowercase							:     Optional[Any]=True							,     _lowercase							:     Union[str, Any]=True							,     _lowercase							:     Any=True							,     _lowercase							:     Dict=9_9							,     _lowercase							:     Optional[int]=3_2							,     _lowercase							:     Optional[int]=5							,     _lowercase							:     Tuple=4							,     _lowercase							:     Dict=3_7							,     _lowercase							:     Optional[int]="gelu"							,     _lowercase							:     Union[str, Any]=0.1							,     _lowercase							:     Dict=0.1							,     _lowercase							:     Optional[int]=5_1_2							,     _lowercase							:     List[str]=1_6							,     _lowercase							:     List[str]=2							,     _lowercase							:     Optional[Any]=0.02							,     _lowercase							:     List[Any]=3							,     _lowercase							:     Tuple=4							,     _lowercase							:     List[Any]=None							,     _lowercase							:     List[str]=1_0_0_0							,     ):


										'''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 							A			(  self							:     Tuple  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.seq_length]							,     self.vocab_size  )

										UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.seq_length, 4]							,     self.range_bbox  )
										# 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__       						=		None
										if self.use_input_mask:
																UpperCAmelCase__       						=		ids_tensor([self.batch_size, self.seq_length]							,     vocab_size=2  )

										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__       						=		self.get_config()

										return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

				def 							A			(  self							:     str  ):


										'''simple docstring'''
										return 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							,     )

				def 							A			(  self							:     Dict							,     _lowercase							:     List[Any]							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     int							,     _lowercase							:     List[Any]							,     _lowercase							:     Optional[int]							,     _lowercase							:     Dict							,     _lowercase							:     Optional[int]							,     _lowercase							:     List[str]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMModel(config=_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase  )
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase							,     token_type_ids=_lowercase  )
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase  )
										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							:     List[str]							,     _lowercase							:     Optional[int]							,     _lowercase							:     Tuple							,     _lowercase							:     Dict							,     _lowercase							:     int							,     _lowercase							:     Tuple							,     _lowercase							:     int							,     _lowercase							:     Optional[int]							,     _lowercase							:     Optional[int]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMForMaskedLM(config=_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=_lowercase  )
										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.vocab_size)  )

				def 							A			(  self							:     Union[str, Any]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Dict							,     _lowercase							:     Tuple							,     _lowercase							:     List[Any]							,     _lowercase							:     str							,     _lowercase							:     Optional[int]							,     _lowercase							:     str  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.num_labels
										UpperCAmelCase__       						=		LayoutLMForSequenceClassification(_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(
										    _lowercase							,     _lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=_lowercase  )
										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.num_labels)  )

				def 							A			(  self							:     Dict							,     _lowercase							:     Dict							,     _lowercase							:     Any							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     int							,     _lowercase							:     List[str]							,     _lowercase							:     Optional[Any]							,     _lowercase							:     Any							,     _lowercase							:     int  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.num_labels
										UpperCAmelCase__       						=		LayoutLMForTokenClassification(config=_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(_lowercase							,     _lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=_lowercase  )
										self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.seq_length, self.num_labels)  )

				def 							A			(  self							:     List[Any]							,     _lowercase							:     Dict							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Tuple							,     _lowercase							:     Union[str, Any]							,     _lowercase							:     Optional[int]							,     _lowercase							:     Tuple							,     _lowercase							:     Optional[int]							,     _lowercase							:     Union[str, Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMForQuestionAnswering(config=_lowercase  )
										model.to(_lowercase  )
										model.eval()
										UpperCAmelCase__       						=		model(
										    _lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     start_positions=_lowercase							,     end_positions=_lowercase							,     )
										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							:     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_torch
class       _lowercase		( __lowerCamelCase   ,   __lowerCamelCase   ,   unittest.TestCase	):
				lowerCamelCase__							=							(
				    (
				        LayoutLMModel,
				        LayoutLMForMaskedLM,
				        LayoutLMForSequenceClassification,
				        LayoutLMForTokenClassification,
				        LayoutLMForQuestionAnswering,
				    )
				    if is_torch_available()
				    else None
				)
				lowerCamelCase__							=							(
				    {
				        'document-question-answering': LayoutLMForQuestionAnswering,
				        'feature-extraction': LayoutLMModel,
				        'fill-mask': LayoutLMForMaskedLM,
				        'text-classification': LayoutLMForSequenceClassification,
				        'token-classification': LayoutLMForTokenClassification,
				        'zero-shot': LayoutLMForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				lowerCamelCase__							=							True

				def 							A			(  self							:     Union[str, Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMModelTester(self  )
										UpperCAmelCase__       						=		ConfigTester(self							,     config_class=_lowercase							,     hidden_size=3_7  )

				def 							A			(  self							:     str  ):


										'''simple docstring'''
										self.config_tester.run_common_tests()

				def 							A			(  self							:     Any  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowercase  )

				def 							A			(  self							:     Optional[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
																UpperCAmelCase__       						=		type
																self.model_tester.create_and_check_model(*_lowercase  )

				def 							A			(  self							:     Optional[int]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*_lowercase  )

				def 							A			(  self							:     Optional[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*_lowercase  )

				def 							A			(  self							:     List[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*_lowercase  )

				def 							A			(  self							:     Union[str, Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*_lowercase  )

				@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""  )
				def 							A			(  self							:     str  ):


										'''simple docstring'''
										pass


def 	a__   (		)->						Any:
						# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
						# fmt: off
						UpperCAmelCase__       						=		torch.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]]		,      device=UpperCAmelCase__      )  # noqa: E231
						UpperCAmelCase__       						=		torch.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],]		,      device=UpperCAmelCase__      )  # noqa: E231
						UpperCAmelCase__       						=		torch.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]]]		,      device=UpperCAmelCase__      )  # noqa: E231
						UpperCAmelCase__       						=		torch.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]]		,      device=UpperCAmelCase__      )  # noqa: E231
						# these are sequence labels (i.e. at the token level)
						UpperCAmelCase__       						=		torch.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]]		,      device=UpperCAmelCase__      )  # noqa: E231
						# fmt: on

						return input_ids, attention_mask, bbox, token_type_ids, labels







@require_torch
class       _lowercase		( unittest.TestCase	):

				@slow
				def 							A			(  self							:     List[Any]  ):


										'''simple docstring'''
										UpperCAmelCase__       						=		LayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""  ).to(_lowercase  )

										UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__       						=		prepare_layoutlm_batch_inputs()

										# forward pass
										UpperCAmelCase__       						=		model(input_ids=_lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase  )

										# test the sequence output on [0, :3, :3]
										UpperCAmelCase__       						=		torch.tensor(
										    [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]							,     device=_lowercase							,     )

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

										# test the pooled output on [1, :3]
										UpperCAmelCase__       						=		torch.tensor([-0.6580, -0.0214, 0.8552]							,     device=_lowercase  )

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

				@slow
				def 							A			(  self							:     Optional[Any]  ):


										'''simple docstring'''
										# initialize model with randomly initialized sequence classification head
										UpperCAmelCase__       						=		LayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""							,     num_labels=2  ).to(
										    _lowercase  )

										UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__       						=		prepare_layoutlm_batch_inputs()

										# forward pass
										UpperCAmelCase__       						=		model(
										    input_ids=_lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=torch.tensor([1, 1]							,     device=_lowercase  )							,     )

										# test whether we get a loss as a scalar
										UpperCAmelCase__       						=		outputs.loss
										UpperCAmelCase__       						=		torch.Size([]  )
										self.assertEqual(loss.shape							,     _lowercase  )

										# test the shape of the logits
										UpperCAmelCase__       						=		outputs.logits
										UpperCAmelCase__       						=		torch.Size((2, 2)  )
										self.assertEqual(logits.shape							,     _lowercase  )

				@slow
				def 							A			(  self							:     Any  ):


										'''simple docstring'''
										# initialize model with randomly initialized token classification head
										UpperCAmelCase__       						=		LayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""							,     num_labels=1_3  ).to(
										    _lowercase  )

										UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__       						=		prepare_layoutlm_batch_inputs()

										# forward pass
										UpperCAmelCase__       						=		model(
										    input_ids=_lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase							,     labels=_lowercase  )

										# test the loss calculation to be around 2.65
										# expected_loss = torch.tensor(2.65, device=torch_device)

										# The loss is currently somewhat random and can vary between 0.1-0.3 atol.
										# self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

										# test the shape of the logits
										UpperCAmelCase__       						=		outputs.logits
										UpperCAmelCase__       						=		torch.Size((2, 2_5, 1_3)  )
										self.assertEqual(logits.shape							,     _lowercase  )

				@slow
				def 							A			(  self							:     Optional[int]  ):


										'''simple docstring'''
										# initialize model with randomly initialized token classification head
										UpperCAmelCase__       						=		LayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""  ).to(_lowercase  )

										UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__						,   UpperCAmelCase__       						=		prepare_layoutlm_batch_inputs()

										# forward pass
										UpperCAmelCase__       						=		model(input_ids=_lowercase							,     bbox=_lowercase							,     attention_mask=_lowercase							,     token_type_ids=_lowercase  )

										# test the shape of the logits
										UpperCAmelCase__       						=		torch.Size((2, 2_5)  )
										self.assertEqual(outputs.start_logits.shape							,     _lowercase  )
										self.assertEqual(outputs.end_logits.shape							,     _lowercase  )

