






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					:   Dict							,   SCREAMING_SNAKE_CASE					:   str							,   SCREAMING_SNAKE_CASE					:   Optional[Any]=13							,   SCREAMING_SNAKE_CASE					:   List[Any]=7							,   SCREAMING_SNAKE_CASE					:   List[Any]=True							,   SCREAMING_SNAKE_CASE					:   int=True							,   SCREAMING_SNAKE_CASE					:   Optional[int]=True							,   SCREAMING_SNAKE_CASE					:   Tuple=True							,   SCREAMING_SNAKE_CASE					:   Tuple=99							,   SCREAMING_SNAKE_CASE					:   Tuple=32							,   SCREAMING_SNAKE_CASE					:   int=2							,   SCREAMING_SNAKE_CASE					:   Any=4							,   SCREAMING_SNAKE_CASE					:   Optional[Any]=37							,   SCREAMING_SNAKE_CASE					:   Tuple="gelu"							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]=0.1							,   SCREAMING_SNAKE_CASE					:   Optional[Any]=0.1							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]=5_12							,   SCREAMING_SNAKE_CASE					:   Tuple=16							,   SCREAMING_SNAKE_CASE					:   str=2							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]=0.0_2							,   SCREAMING_SNAKE_CASE					:   List[Any]=3							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]=4							,   SCREAMING_SNAKE_CASE					:   List[Any]=None							,   SCREAMING_SNAKE_CASE					:   Optional[int]=10_00							,   ):


      '''simple docstring'''






      UpperCamelCase__			:   Tuple       				=  parent
      UpperCamelCase__			:   Optional[int]       				=  batch_size
      UpperCamelCase__			:   Optional[int]       				=  seq_length
      UpperCamelCase__			:   Dict       				=  is_training
      UpperCamelCase__			:   List[str]       				=  use_input_mask
      UpperCamelCase__			:   Dict       				=  use_token_type_ids
      UpperCamelCase__			:   Union[str, Any]       				=  use_labels
      UpperCamelCase__			:   int       				=  vocab_size
      UpperCamelCase__			:   str       				=  hidden_size
      UpperCamelCase__			:   int       				=  num_hidden_layers
      UpperCamelCase__			:   Dict       				=  num_attention_heads
      UpperCamelCase__			:   str       				=  intermediate_size
      UpperCamelCase__			:   Tuple       				=  hidden_act
      UpperCamelCase__			:   Union[str, Any]       				=  hidden_dropout_prob
      UpperCamelCase__			:   Optional[int]       				=  attention_probs_dropout_prob
      UpperCamelCase__			:   Optional[Any]       				=  max_position_embeddings
      UpperCamelCase__			:   Any       				=  type_vocab_size
      UpperCamelCase__			:   List[Any]       				=  type_sequence_label_size
      UpperCamelCase__			:   List[Any]       				=  initializer_range
      UpperCamelCase__			:   Any       				=  num_labels
      UpperCamelCase__			:   str       				=  num_choices
      UpperCamelCase__			:   Dict       				=  scope
      UpperCamelCase__			:   str       				=  range_bbox







 def 					__lowercase					(		self					:   str						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[int]       				=  ids_tensor([self.batch_size, self.seq_length]							,   self.vocab_size						)

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

      UpperCamelCase__			:   Any       				=  None
      if self.use_input_mask:
           UpperCamelCase__			:   Dict       				=  random_attention_mask([self.batch_size, self.seq_length]						)

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

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

      UpperCamelCase__			:   Optional[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 					__lowercase					(		self					:   str							,   SCREAMING_SNAKE_CASE					:   Tuple							,   SCREAMING_SNAKE_CASE					:   List[Any]							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   Optional[int]							,   SCREAMING_SNAKE_CASE					:   List[Any]							,   SCREAMING_SNAKE_CASE					:   Tuple							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   int						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[Any]       				=  TFLayoutLMModel(config=SCREAMING_SNAKE_CASE						)

      UpperCamelCase__			:   Tuple       				=  model(SCREAMING_SNAKE_CASE							,   SCREAMING_SNAKE_CASE							,   attention_mask=SCREAMING_SNAKE_CASE							,   token_type_ids=SCREAMING_SNAKE_CASE						)
      UpperCamelCase__			:   List[str]       				=  model(SCREAMING_SNAKE_CASE							,   SCREAMING_SNAKE_CASE							,   token_type_ids=SCREAMING_SNAKE_CASE						)
      UpperCamelCase__			:   Union[str, Any]       				=  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 					__lowercase					(		self					:   int							,   SCREAMING_SNAKE_CASE					:   List[Any]							,   SCREAMING_SNAKE_CASE					:   Optional[Any]							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   int							,   SCREAMING_SNAKE_CASE					:   List[Any]							,   SCREAMING_SNAKE_CASE					:   int							,   SCREAMING_SNAKE_CASE					:   Any							,   SCREAMING_SNAKE_CASE					:   Any						):


      '''simple docstring'''






      UpperCamelCase__			:   str       				=  TFLayoutLMForMaskedLM(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.vocab_size)						)







 def 					__lowercase					(		self					:   List[Any]							,   SCREAMING_SNAKE_CASE					:   List[str]							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   str							,   SCREAMING_SNAKE_CASE					:   Tuple							,   SCREAMING_SNAKE_CASE					:   str							,   SCREAMING_SNAKE_CASE					:   int							,   SCREAMING_SNAKE_CASE					:   Optional[int]							,   SCREAMING_SNAKE_CASE					:   Optional[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   Union[str, Any]       				=  self.num_labels
      UpperCamelCase__			:   int       				=  TFLayoutLMForSequenceClassification(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						)
      self.parent.assertEqual(result.logits.shape							,   (self.batch_size, self.num_labels)						)







 def 					__lowercase					(		self					:   Any							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   SCREAMING_SNAKE_CASE					:   str							,   SCREAMING_SNAKE_CASE					:   Optional[Any]							,   SCREAMING_SNAKE_CASE					:   Optional[int]							,   SCREAMING_SNAKE_CASE					:   Tuple							,   SCREAMING_SNAKE_CASE					:   Dict							,   SCREAMING_SNAKE_CASE					:   Tuple						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[Any]       				=  self.num_labels
      UpperCamelCase__			:   str       				=  TFLayoutLMForTokenClassification(config=SCREAMING_SNAKE_CASE						)

      UpperCamelCase__			:   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 					__lowercase					(		self					:   Dict							,   SCREAMING_SNAKE_CASE					:   str							,   SCREAMING_SNAKE_CASE					:   List[Any]							,   SCREAMING_SNAKE_CASE					:   List[str]							,   SCREAMING_SNAKE_CASE					:   Tuple							,   SCREAMING_SNAKE_CASE					:   int							,   SCREAMING_SNAKE_CASE					:   Optional[int]							,   SCREAMING_SNAKE_CASE					:   int							,   SCREAMING_SNAKE_CASE					:   str						):


      '''simple docstring'''






      UpperCamelCase__			:   Tuple       				=  TFLayoutLMForQuestionAnswering(config=SCREAMING_SNAKE_CASE						)

      UpperCamelCase__			:   List[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 					__lowercase					(		self					:   Dict						):


      '''simple docstring'''






      UpperCamelCase__			:   Tuple       				=  self.prepare_config_and_inputs()
      (
          (
          UpperCamelCase__
      )				,     (
          UpperCamelCase__
      )				,     (
          UpperCamelCase__
      )				,     (
          UpperCamelCase__
      )				,     (
          UpperCamelCase__
      )				,     (
          UpperCamelCase__
      )				,     (
          UpperCamelCase__
      )				,     (
          UpperCamelCase__
      )				,     
      )			:   List[str]       				=  config_and_inputs
      UpperCamelCase__			:   Optional[int]       				=  {
          "input_ids": input_ids,
          "bbox": bbox,
          "token_type_ids": token_type_ids,
          "attention_mask": input_mask,
      }
      return config, inputs_dict







@require_tf
class 			__a  (    A__       ,   A__       ,   unittest.TestCase       ):
 _lowerCAmelCase       :       int        = (
     (
         TFLayoutLMModel,
         TFLayoutLMForMaskedLM,
         TFLayoutLMForTokenClassification,
         TFLayoutLMForSequenceClassification,
         TFLayoutLMForQuestionAnswering,
     )
     if is_tf_available()
     else ()
 )
 _lowerCAmelCase       :       Tuple        = (
     {
         '''feature-extraction''': TFLayoutLMModel,
         '''fill-mask''': TFLayoutLMForMaskedLM,
         '''text-classification''': TFLayoutLMForSequenceClassification,
         '''token-classification''': TFLayoutLMForTokenClassification,
         '''zero-shot''': TFLayoutLMForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 _lowerCAmelCase       :       Optional[Any]        = False
 _lowerCAmelCase       :       Any        = True
 _lowerCAmelCase       :       Tuple        = 1_0







 def 					__lowercase					(		self					:   Dict						):


      '''simple docstring'''






      UpperCamelCase__			:   List[Any]       				=  TFLayoutLMModelTester(self						)
      UpperCamelCase__			:   Tuple       				=  ConfigTester(self							,   config_class=SCREAMING_SNAKE_CASE							,   hidden_size=37						)







 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      self.config_tester.run_common_tests()







 def 					__lowercase					(		self					:   int						):


      '''simple docstring'''






      UpperCamelCase__			:   List[str]       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      UpperCamelCase__			:   int       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      UpperCamelCase__			:   List[str]       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   int						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[Any]       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   int						):


      '''simple docstring'''






      UpperCamelCase__			:   Union[str, Any]       				=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE						)







 @slow
 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase__			:   int       				=  TFLayoutLMModel.from_pretrained(SCREAMING_SNAKE_CASE						)
           self.assertIsNotNone(SCREAMING_SNAKE_CASE						)







 @unittest.skip("Onnx compliancy broke with TF 2.10"						)
 def 					__lowercase					(		self					:   Any						):


      '''simple docstring'''






      pass







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

     return input_ids, attention_mask, bbox, token_type_ids, labels





@require_tf
class 			__a  (    unittest.TestCase       ):







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


      '''simple docstring'''






      UpperCamelCase__			:   Optional[Any]       				=  TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"						)

      UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__			:   List[Any]       				=  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						)

      # test the sequence output on [0, :3, :3]
      UpperCamelCase__			:   str       				=  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__			:   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 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      UpperCamelCase__			:   Union[str, Any]       				=  TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"							,   num_labels=2						)

      UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__			:   Optional[int]       				=  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=tf.convert_to_tensor([1, 1]						)							,   )

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

      # test the shape of the logits
      UpperCamelCase__			:   List[str]       				=  outputs.logits
      UpperCamelCase__			:   int       				=  (2, 2)
      self.assertEqual(logits.shape							,   SCREAMING_SNAKE_CASE						)







 @slow
 def 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      UpperCamelCase__			:   Tuple       				=  TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"							,   num_labels=13						)

      UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__			:   List[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__			:   Optional[int]       				=  outputs.logits
      UpperCamelCase__			:   Optional[int]       				=  tf.convert_to_tensor((2, 25, 13)						)
      self.assertEqual(logits.shape							,   SCREAMING_SNAKE_CASE						)







 @slow
 def 					__lowercase					(		self					:   int						):


      '''simple docstring'''






      UpperCamelCase__			:   Optional[Any]       				=  TFLayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"						)

      UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__				,     UpperCamelCase__			:   Optional[int]       				=  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						)

      # test the shape of the logits
      UpperCamelCase__			:   Dict       				=  tf.convert_to_tensor((2, 25)						)
      self.assertEqual(outputs.start_logits.shape							,   SCREAMING_SNAKE_CASE						)
      self.assertEqual(outputs.end_logits.shape							,   SCREAMING_SNAKE_CASE						)







import copy
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


lowerCamelCase	:							Tuple				=logging.get_logger(__name__)

lowerCamelCase	:							Optional[Any]				={
    '''microsoft/conditional-detr-resnet-50''': (
        '''https://huggingface.co/microsoft/conditional-detr-resnet-50/resolve/main/config.json'''
    ),
}





class 			__a  (    A__       ):
 _lowerCAmelCase       :       Optional[Any]        = '''conditional_detr'''
 _lowerCAmelCase       :       List[Any]        = ['''past_key_values''']
 _lowerCAmelCase       :       List[str]        = {
     '''hidden_size''': '''d_model''',
     '''num_attention_heads''': '''encoder_attention_heads''',
 }







 def __init__(		self					:   str							,   SCREAMING_SNAKE_CASE					:   Tuple=True							,   SCREAMING_SNAKE_CASE					:   Optional[int]=None							,   SCREAMING_SNAKE_CASE					:   Tuple=3							,   SCREAMING_SNAKE_CASE					:   Any=3_00							,   SCREAMING_SNAKE_CASE					:   Tuple=6							,   SCREAMING_SNAKE_CASE					:   int=20_48							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]=8							,   SCREAMING_SNAKE_CASE					:   int=6							,   SCREAMING_SNAKE_CASE					:   Dict=20_48							,   SCREAMING_SNAKE_CASE					:   Optional[int]=8							,   SCREAMING_SNAKE_CASE					:   Dict=0.0							,   SCREAMING_SNAKE_CASE					:   List[Any]=0.0							,   SCREAMING_SNAKE_CASE					:   int=True							,   SCREAMING_SNAKE_CASE					:   int="relu"							,   SCREAMING_SNAKE_CASE					:   Any=2_56							,   SCREAMING_SNAKE_CASE					:   int=0.1							,   SCREAMING_SNAKE_CASE					:   int=0.0							,   SCREAMING_SNAKE_CASE					:   Optional[int]=0.0							,   SCREAMING_SNAKE_CASE					:   List[str]=0.0_2							,   SCREAMING_SNAKE_CASE					:   Optional[int]=1.0							,   SCREAMING_SNAKE_CASE					:   List[str]=False							,   SCREAMING_SNAKE_CASE					:   int="sine"							,   SCREAMING_SNAKE_CASE					:   str="resnet50"							,   SCREAMING_SNAKE_CASE					:   int=True							,   SCREAMING_SNAKE_CASE					:   Tuple=False							,   SCREAMING_SNAKE_CASE					:   Tuple=2							,   SCREAMING_SNAKE_CASE					:   Tuple=5							,   SCREAMING_SNAKE_CASE					:   List[str]=2							,   SCREAMING_SNAKE_CASE					:   List[str]=1							,   SCREAMING_SNAKE_CASE					:   Optional[Any]=1							,   SCREAMING_SNAKE_CASE					:   str=2							,   SCREAMING_SNAKE_CASE					:   Any=5							,   SCREAMING_SNAKE_CASE					:   int=2							,   SCREAMING_SNAKE_CASE					:   List[Any]=0.2_5							,   **SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   ):


      '''simple docstring'''






      if backbone_config is not None and use_timm_backbone:
           raise ValueError("You can't specify both `backbone_config` and `use_timm_backbone`."						)

      if not use_timm_backbone:
           if backbone_config is None:
                logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."						)
                UpperCamelCase__			:   Tuple       				=  CONFIG_MAPPING["resnet"](out_features=["stage4"]						)
           elif isinstance(SCREAMING_SNAKE_CASE							,   SCREAMING_SNAKE_CASE						):
                UpperCamelCase__			:   Union[str, Any]       				=  backbone_config.get("model_type"						)
                UpperCamelCase__			:   Tuple       				=  CONFIG_MAPPING[backbone_model_type]
                UpperCamelCase__			:   Any       				=  config_class.from_dict(SCREAMING_SNAKE_CASE						)

      UpperCamelCase__			:   Optional[Any]       				=  use_timm_backbone
      UpperCamelCase__			:   List[Any]       				=  backbone_config
      UpperCamelCase__			:   Tuple       				=  num_channels
      UpperCamelCase__			:   List[Any]       				=  num_queries
      UpperCamelCase__			:   Dict       				=  d_model
      UpperCamelCase__			:   Any       				=  encoder_ffn_dim
      UpperCamelCase__			:   List[str]       				=  encoder_layers
      UpperCamelCase__			:   List[str]       				=  encoder_attention_heads
      UpperCamelCase__			:   Optional[int]       				=  decoder_ffn_dim
      UpperCamelCase__			:   str       				=  decoder_layers
      UpperCamelCase__			:   Optional[Any]       				=  decoder_attention_heads
      UpperCamelCase__			:   int       				=  dropout
      UpperCamelCase__			:   Optional[int]       				=  attention_dropout
      UpperCamelCase__			:   Any       				=  activation_dropout
      UpperCamelCase__			:   int       				=  activation_function
      UpperCamelCase__			:   int       				=  init_std
      UpperCamelCase__			:   List[Any]       				=  init_xavier_std
      UpperCamelCase__			:   List[str]       				=  encoder_layerdrop
      UpperCamelCase__			:   List[Any]       				=  decoder_layerdrop
      UpperCamelCase__			:   List[Any]       				=  encoder_layers
      UpperCamelCase__			:   Optional[Any]       				=  auxiliary_loss
      UpperCamelCase__			:   List[str]       				=  position_embedding_type
      UpperCamelCase__			:   Optional[Any]       				=  backbone
      UpperCamelCase__			:   Optional[int]       				=  use_pretrained_backbone
      UpperCamelCase__			:   List[Any]       				=  dilation
      # Hungarian matcher
      UpperCamelCase__			:   List[str]       				=  class_cost
      UpperCamelCase__			:   Union[str, Any]       				=  bbox_cost
      UpperCamelCase__			:   int       				=  giou_cost
      # Loss coefficients
      UpperCamelCase__			:   str       				=  mask_loss_coefficient
      UpperCamelCase__			:   List[Any]       				=  dice_loss_coefficient
      UpperCamelCase__			:   int       				=  cls_loss_coefficient
      UpperCamelCase__			:   Tuple       				=  bbox_loss_coefficient
      UpperCamelCase__			:   Any       				=  giou_loss_coefficient
      UpperCamelCase__			:   List[Any]       				=  focal_alpha
      super().__init__(is_encoder_decoder=SCREAMING_SNAKE_CASE							,   **SCREAMING_SNAKE_CASE						)







 @property
 def 					__lowercase					(		self					:   Union[str, Any]						):


      '''simple docstring'''






      return self.encoder_attention_heads







 @property
 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      return self.d_model







 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   Any       				=  copy.deepcopy(self.__dict__						)
      if self.backbone_config is not None:
           UpperCamelCase__			:   List[str]       				=  self.backbone_config.to_dict()
      UpperCamelCase__			:   int       				=  self.__class__.model_type
      return output







class 			__a  (    A__       ):
 _lowerCAmelCase       :       Tuple        = version.parse('''1.11'''       )







 @property
 def 					__lowercase					(		self					:   Any						):


      '''simple docstring'''






      return OrderedDict(
          [
              ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
              ("pixel_mask", {0: "batch"}),
          ]						)







 @property
 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      return 1e-5







 @property
 def 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      return 12