



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.0_2,   SCREAMING_SNAKE_CASE_=3,   SCREAMING_SNAKE_CASE_=4,   SCREAMING_SNAKE_CASE_=None,   SCREAMING_SNAKE_CASE_=1000,   )       ->   Optional[int]:
						UpperCAmelCase_:		str							      =     parent
						UpperCAmelCase_:		Union[str, Any]							      =     batch_size
						UpperCAmelCase_:		str							      =     seq_length
						UpperCAmelCase_:		Dict							      =     is_training
						UpperCAmelCase_:		List[Any]							      =     use_input_mask
						UpperCAmelCase_:		List[Any]							      =     use_token_type_ids
						UpperCAmelCase_:		Optional[Any]							      =     use_labels
						UpperCAmelCase_:		Tuple							      =     vocab_size
						UpperCAmelCase_:		int							      =     hidden_size
						UpperCAmelCase_:		Tuple							      =     num_hidden_layers
						UpperCAmelCase_:		Optional[Any]							      =     num_attention_heads
						UpperCAmelCase_:		Dict							      =     intermediate_size
						UpperCAmelCase_:		Optional[int]							      =     hidden_act
						UpperCAmelCase_:		List[str]							      =     hidden_dropout_prob
						UpperCAmelCase_:		Any							      =     attention_probs_dropout_prob
						UpperCAmelCase_:		Union[str, Any]							      =     max_position_embeddings
						UpperCAmelCase_:		List[str]							      =     type_vocab_size
						UpperCAmelCase_:		Dict							      =     type_sequence_label_size
						UpperCAmelCase_:		Dict							      =     initializer_range
						UpperCAmelCase_:		Union[str, Any]							      =     num_labels
						UpperCAmelCase_:		List[Any]							      =     num_choices
						UpperCAmelCase_:		Tuple							      =     scope
						UpperCAmelCase_:		List[Any]							      =     range_bbox

			def      __snake_case       (self					)       ->   List[Any]:
						UpperCAmelCase_:		Union[str, Any]							      =     ids_tensor([self.batch_size, self.seq_length],   self.vocab_size					)

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

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

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

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

						UpperCAmelCase_:		int							      =     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      __snake_case       (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_					)       ->   List[str]:
						UpperCAmelCase_:		Optional[int]							      =     TFLayoutLMModel(config=SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Optional[Any]							      =     model(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   attention_mask=SCREAMING_SNAKE_CASE_,   token_type_ids=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Optional[int]							      =     model(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   token_type_ids=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		int							      =     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      __snake_case       (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:
						UpperCAmelCase_:		List[str]							      =     TFLayoutLMForMaskedLM(config=SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Optional[int]							      =     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      __snake_case       (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:
						UpperCAmelCase_:		str							      =     self.num_labels
						UpperCAmelCase_:		Tuple							      =     TFLayoutLMForSequenceClassification(config=SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Optional[int]							      =     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      __snake_case       (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_					)       ->   Union[str, Any]:
						UpperCAmelCase_:		int							      =     self.num_labels
						UpperCAmelCase_:		str							      =     TFLayoutLMForTokenClassification(config=SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Optional[Any]							      =     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      __snake_case       (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]:
						UpperCAmelCase_:		List[Any]							      =     TFLayoutLMForQuestionAnswering(config=SCREAMING_SNAKE_CASE_					)

						UpperCAmelCase_:		Union[str, Any]							      =     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      __snake_case       (self					)       ->   Any:
						UpperCAmelCase_:		List[Any]							      =     self.prepare_config_and_inputs()
						(
						    (
						    UpperCAmelCase_
						)      ,							(
						    UpperCAmelCase_
						)      ,							(
						    UpperCAmelCase_
						)      ,							(
						    UpperCAmelCase_
						)      ,							(
						    UpperCAmelCase_
						)      ,							(
						    UpperCAmelCase_
						)      ,							(
						    UpperCAmelCase_
						)      ,							(
						    UpperCAmelCase_
						)      ,							
						):		Union[str, Any]							      =     config_and_inputs
						UpperCAmelCase_:		str							      =     {
						    """input_ids""": input_ids,
						    """bbox""": bbox,
						    """token_type_ids""": token_type_ids,
						    """attention_mask""": input_mask,
						}
						return config, inputs_dict







@require_tf
class 				_a				(   _lowerCAmelCase ,		_lowerCAmelCase ,		unittest.TestCase					):
			A      		=	(
			    (
			        TFLayoutLMModel,
			        TFLayoutLMForMaskedLM,
			        TFLayoutLMForTokenClassification,
			        TFLayoutLMForSequenceClassification,
			        TFLayoutLMForQuestionAnswering,
			    )
			    if is_tf_available()
			    else ()
			)
			A      		=	(
			    {
			        '''feature-extraction''': TFLayoutLMModel,
			        '''fill-mask''': TFLayoutLMForMaskedLM,
			        '''text-classification''': TFLayoutLMForSequenceClassification,
			        '''token-classification''': TFLayoutLMForTokenClassification,
			        '''zero-shot''': TFLayoutLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			A      		=	False
			A      		=	True
			A      		=	10

			def      __snake_case       (self					)       ->   List[str]:
						UpperCAmelCase_:		str							      =     TFLayoutLMModelTester(self					)
						UpperCAmelCase_:		int							      =     ConfigTester(self,   config_class=SCREAMING_SNAKE_CASE_,   hidden_size=37					)

			def      __snake_case       (self					)       ->   str:
						self.config_tester.run_common_tests()

			def      __snake_case       (self					)       ->   List[str]:
						UpperCAmelCase_:		Optional[int]							      =     self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self					)       ->   Any:
						UpperCAmelCase_:		Optional[Any]							      =     self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self					)       ->   str:
						UpperCAmelCase_:		Dict							      =     self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self					)       ->   Any:
						UpperCAmelCase_:		Dict							      =     self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self					)       ->   Any:
						UpperCAmelCase_:		str							      =     self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE_					)

			@slow
			def      __snake_case       (self					)       ->   Union[str, Any]:
						for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									UpperCAmelCase_:		str							      =     TFLayoutLMModel.from_pretrained(SCREAMING_SNAKE_CASE_					)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE_					)

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







def  lowerCAmelCase_	():





			"""simple docstring"""


			UpperCAmelCase_:		Union[str, Any]							      =     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_:		int							      =     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_:		Optional[Any]							      =     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_:		int							      =     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_:		Optional[Any]							      =     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      __snake_case       (self					)       ->   Optional[int]:
						UpperCAmelCase_:		Any							      =     TFLayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""					)

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

						# forward pass
						UpperCAmelCase_:		Tuple							      =     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_:		Union[str, Any]							      =     tf.convert_to_tensor(
						    [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]],   )

						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_:		Optional[Any]							      =     tf.convert_to_tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]					)

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

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

						UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_:		List[str]							      =     prepare_layoutlm_batch_inputs()

						# forward pass
						UpperCAmelCase_:		Union[str, Any]							      =     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_:		List[Any]							      =     outputs.loss
						UpperCAmelCase_:		List[Any]							      =     (2,)
						self.assertEqual(loss.shape,   SCREAMING_SNAKE_CASE_					)

						# test the shape of the logits
						UpperCAmelCase_:		List[Any]							      =     outputs.logits
						UpperCAmelCase_:		List[str]							      =     (2, 2)
						self.assertEqual(logits.shape,   SCREAMING_SNAKE_CASE_					)

			@slow
			def      __snake_case       (self					)       ->   Optional[Any]:
						# initialize model with randomly initialized token classification head
						UpperCAmelCase_:		Dict							      =     TFLayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased""",   num_labels=13					)

						UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_:		Union[str, Any]							      =     prepare_layoutlm_batch_inputs()

						# forward pass
						UpperCAmelCase_:		Optional[int]							      =     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_:		List[str]							      =     outputs.logits
						UpperCAmelCase_:		Tuple							      =     tf.convert_to_tensor((2, 25, 13)					)
						self.assertEqual(logits.shape,   SCREAMING_SNAKE_CASE_					)

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

						UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_:		int							      =     prepare_layoutlm_batch_inputs()

						# forward pass
						UpperCAmelCase_:		str							      =     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_:		List[Any]							      =     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 Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


a      :  List[str]			     =			logging.get_logger(__name__)


if is_vision_available():
	import PIL







class 				_a				(   _lowerCAmelCase					):
			A      		=	['''pixel_values''']

			def __init__(self,   SCREAMING_SNAKE_CASE_ = True,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = PILImageResampling.BICUBIC,   SCREAMING_SNAKE_CASE_ = True,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = True,   SCREAMING_SNAKE_CASE_ = 1 / 255,   SCREAMING_SNAKE_CASE_ = True,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = True,   **SCREAMING_SNAKE_CASE_,   )       ->   None:
						super().__init__(**SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Optional[Any]							      =     size if size is not None else {"""shortest_edge""": 224}
						UpperCAmelCase_:		int							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   default_to_square=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Dict							      =     crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
						UpperCAmelCase_:		Union[str, Any]							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   default_to_square=SCREAMING_SNAKE_CASE_,   param_name="""crop_size"""					)

						UpperCAmelCase_:		Optional[int]							      =     do_resize
						UpperCAmelCase_:		Optional[int]							      =     size
						UpperCAmelCase_:		Optional[int]							      =     resample
						UpperCAmelCase_:		Tuple							      =     do_center_crop
						UpperCAmelCase_:		Optional[int]							      =     crop_size
						UpperCAmelCase_:		str							      =     do_rescale
						UpperCAmelCase_:		Optional[int]							      =     rescale_factor
						UpperCAmelCase_:		List[str]							      =     do_normalize
						UpperCAmelCase_:		Any							      =     image_mean if image_mean is not None else OPENAI_CLIP_MEAN
						UpperCAmelCase_:		Dict							      =     image_std if image_std is not None else OPENAI_CLIP_STD
						UpperCAmelCase_:		Any							      =     do_convert_rgb

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = PILImageResampling.BICUBIC,   SCREAMING_SNAKE_CASE_ = None,   **SCREAMING_SNAKE_CASE_,   )       ->   np.ndarray:
						UpperCAmelCase_:		Optional[Any]							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   default_to_square=SCREAMING_SNAKE_CASE_					)
						if "shortest_edge" not in size:
									raise ValueError(f'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'					)
						UpperCAmelCase_:		Optional[Any]							      =     get_resize_output_image_size(SCREAMING_SNAKE_CASE_,   size=size["""shortest_edge"""],   default_to_square=SCREAMING_SNAKE_CASE_					)
						return resize(SCREAMING_SNAKE_CASE_,   size=SCREAMING_SNAKE_CASE_,   resample=SCREAMING_SNAKE_CASE_,   data_format=SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   **SCREAMING_SNAKE_CASE_,   )       ->   np.ndarray:
						UpperCAmelCase_:		Any							      =     get_size_dict(SCREAMING_SNAKE_CASE_					)
						if "height" not in size or "width" not in size:
									raise ValueError(f'The `size` parameter must contain the keys (height, width). Got {size.keys()}'					)
						return center_crop(SCREAMING_SNAKE_CASE_,   size=(size["""height"""], size["""width"""]),   data_format=SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   **SCREAMING_SNAKE_CASE_,   )       ->   Union[str, Any]:
						return rescale(SCREAMING_SNAKE_CASE_,   scale=SCREAMING_SNAKE_CASE_,   data_format=SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   **SCREAMING_SNAKE_CASE_,   )       ->   np.ndarray:
						return normalize(SCREAMING_SNAKE_CASE_,   mean=SCREAMING_SNAKE_CASE_,   std=SCREAMING_SNAKE_CASE_,   data_format=SCREAMING_SNAKE_CASE_,   **SCREAMING_SNAKE_CASE_					)

			def      __snake_case       (self,   SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = None,   SCREAMING_SNAKE_CASE_ = ChannelDimension.FIRST,   **SCREAMING_SNAKE_CASE_,   )       ->   PIL.Image.Image:
						UpperCAmelCase_:		Tuple							      =     do_resize if do_resize is not None else self.do_resize
						UpperCAmelCase_:		Tuple							      =     size if size is not None else self.size
						UpperCAmelCase_:		str							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   param_name="""size""",   default_to_square=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		List[str]							      =     resample if resample is not None else self.resample
						UpperCAmelCase_:		Optional[int]							      =     do_center_crop if do_center_crop is not None else self.do_center_crop
						UpperCAmelCase_:		Tuple							      =     crop_size if crop_size is not None else self.crop_size
						UpperCAmelCase_:		int							      =     get_size_dict(SCREAMING_SNAKE_CASE_,   param_name="""crop_size""",   default_to_square=SCREAMING_SNAKE_CASE_					)
						UpperCAmelCase_:		Union[str, Any]							      =     do_rescale if do_rescale is not None else self.do_rescale
						UpperCAmelCase_:		int							      =     rescale_factor if rescale_factor is not None else self.rescale_factor
						UpperCAmelCase_:		Tuple							      =     do_normalize if do_normalize is not None else self.do_normalize
						UpperCAmelCase_:		Dict							      =     image_mean if image_mean is not None else self.image_mean
						UpperCAmelCase_:		int							      =     image_std if image_std is not None else self.image_std
						UpperCAmelCase_:		Union[str, Any]							      =     do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

						UpperCAmelCase_:		List[str]							      =     make_list_of_images(SCREAMING_SNAKE_CASE_					)

						if not valid_images(SCREAMING_SNAKE_CASE_					):
									raise ValueError(
									    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
									    """torch.Tensor, tf.Tensor or jax.ndarray."""					)

						if do_resize and size is None:
									raise ValueError("""Size must be specified if do_resize is True."""					)

						if do_center_crop and crop_size is None:
									raise ValueError("""Crop size must be specified if do_center_crop is True."""					)

						if do_rescale and rescale_factor is None:
									raise ValueError("""Rescale factor must be specified if do_rescale is True."""					)

						if do_normalize and (image_mean is None or image_std is None):
									raise ValueError("""Image mean and std must be specified if do_normalize is True."""					)

						# PIL RGBA images are converted to RGB
						if do_convert_rgb:
									UpperCAmelCase_:		Any							      =     [convert_to_rgb(SCREAMING_SNAKE_CASE_					) for image in images]

						# All transformations expect numpy arrays.
						UpperCAmelCase_:		List[str]							      =     [to_numpy_array(SCREAMING_SNAKE_CASE_					) for image in images]

						if do_resize:
									UpperCAmelCase_:		str							      =     [self.resize(image=SCREAMING_SNAKE_CASE_,   size=SCREAMING_SNAKE_CASE_,   resample=SCREAMING_SNAKE_CASE_					) for image in images]

						if do_center_crop:
									UpperCAmelCase_:		Dict							      =     [self.center_crop(image=SCREAMING_SNAKE_CASE_,   size=SCREAMING_SNAKE_CASE_					) for image in images]

						if do_rescale:
									UpperCAmelCase_:		Optional[Any]							      =     [self.rescale(image=SCREAMING_SNAKE_CASE_,   scale=SCREAMING_SNAKE_CASE_					) for image in images]

						if do_normalize:
									UpperCAmelCase_:		Dict							      =     [self.normalize(image=SCREAMING_SNAKE_CASE_,   mean=SCREAMING_SNAKE_CASE_,   std=SCREAMING_SNAKE_CASE_					) for image in images]

						UpperCAmelCase_:		Tuple							      =     [to_channel_dimension_format(SCREAMING_SNAKE_CASE_,   SCREAMING_SNAKE_CASE_					) for image in images]

						UpperCAmelCase_:		Union[str, Any]							      =     {"""pixel_values""": images}
						return BatchFeature(data=SCREAMING_SNAKE_CASE_,   tensor_type=SCREAMING_SNAKE_CASE_					)






