



'''simple docstring'''





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    :



 '''simple docstring'''







 def __init__(self				,     A				,     A=13				,     A=7				,     A=True				,     A=True				,     A=True				,     A=True				,     A=99				,     A=32				,     A=2				,     A=4				,     A=37				,     A="gelu"				,     A=0.1				,     A=0.1				,     A=512				,     A=16				,     A=2				,     A=0.02				,     A=3				,     A=4				,     A=None				,     A=1_000				,     )					->  List[str]:


      """simple docstring"""



      _a											=						parent
      _a											=						batch_size
      _a											=						seq_length
      _a											=						is_training
      _a											=						use_input_mask
      _a											=						use_token_type_ids
      _a											=						use_labels
      _a											=						vocab_size
      _a											=						hidden_size
      _a											=						num_hidden_layers
      _a											=						num_attention_heads
      _a											=						intermediate_size
      _a											=						hidden_act
      _a											=						hidden_dropout_prob
      _a											=						attention_probs_dropout_prob
      _a											=						max_position_embeddings
      _a											=						type_vocab_size
      _a											=						type_sequence_label_size
      _a											=						initializer_range
      _a											=						num_labels
      _a											=						num_choices
      _a											=						scope
      _a											=						range_bbox



 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a											=						ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size )

      # convert bbox to numpy since TF does not support item assignment
      _a											=						ids_tensor([self.batch_size, self.seq_length, 4]				,     self.range_bbox ).numpy()
      # Ensure that bbox is legal
      for i in range(bbox.shape[0] ):
           for j in range(bbox.shape[1] ):
                if bbox[i, j, 3] < bbox[i, j, 1]:
                     _a											=						bbox[i, j, 3]
                     _a											=						bbox[i, j, 1]
                     _a											=						t
                if bbox[i, j, 2] < bbox[i, j, 0]:
                     _a											=						bbox[i, j, 2]
                     _a											=						bbox[i, j, 0]
                     _a											=						t
      _a											=						tf.convert_to_tensor(A )

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

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

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

      _a											=						LayoutLMConfig(
          vocab_size=self.vocab_size				,     hidden_size=self.hidden_size				,     num_hidden_layers=self.num_hidden_layers				,     num_attention_heads=self.num_attention_heads				,     intermediate_size=self.intermediate_size				,     hidden_act=self.hidden_act				,     hidden_dropout_prob=self.hidden_dropout_prob				,     attention_probs_dropout_prob=self.attention_probs_dropout_prob				,     max_position_embeddings=self.max_position_embeddings				,     type_vocab_size=self.type_vocab_size				,     initializer_range=self.initializer_range				,     )

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



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


      """simple docstring"""



      _a											=						TFLayoutLMModel(config=A )

      _a											=						model(A				,     A				,     attention_mask=A				,     token_type_ids=A )
      _a											=						model(A				,     A				,     token_type_ids=A )
      _a											=						model(A				,     A )
      self.parent.assertEqual(result.last_hidden_state.shape				,     (self.batch_size, self.seq_length, self.hidden_size) )
      self.parent.assertEqual(result.pooler_output.shape				,     (self.batch_size, self.hidden_size) )



 def       a__						(self				,     A				,     A				,     A				,     A				,     A				,     A				,     A				,     A )					->  Any:


      """simple docstring"""



      _a											=						TFLayoutLMForMaskedLM(config=A )

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



 def       a__						(self				,     A				,     A				,     A				,     A				,     A				,     A				,     A				,     A )					->  Dict:


      """simple docstring"""



      _a											=						self.num_labels
      _a											=						TFLayoutLMForSequenceClassification(config=A )

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



 def       a__						(self				,     A				,     A				,     A				,     A				,     A				,     A				,     A				,     A )					->  Tuple:


      """simple docstring"""



      _a											=						self.num_labels
      _a											=						TFLayoutLMForTokenClassification(config=A )

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



 def       a__						(self				,     A				,     A				,     A				,     A				,     A				,     A				,     A				,     A )					->  Dict:


      """simple docstring"""



      _a											=						TFLayoutLMForQuestionAnswering(config=A )

      _a											=						model(A				,     A				,     attention_mask=A				,     token_type_ids=A )
      self.parent.assertEqual(result.start_logits.shape				,     (self.batch_size, self.seq_length) )
      self.parent.assertEqual(result.end_logits.shape				,     (self.batch_size, self.seq_length) )



 def       a__						(self )					->  int:


      """simple docstring"""



      _a											=						self.prepare_config_and_inputs()
      (
          (
          _a
      )						,					(
          _a
      )						,					(
          _a
      )						,					(
          _a
      )						,					(
          _a
      )						,					(
          _a
      )						,					(
          _a
      )						,					(
          _a
      )						,					
      )											=						config_and_inputs
      _a											=						{
          '''input_ids''': input_ids,
          '''bbox''': bbox,
          '''token_type_ids''': token_type_ids,
          '''attention_mask''': input_mask,
      }
      return config, inputs_dict






@require_tf
class __A    (						A     ,     A     ,     unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase					: Optional[int]    = (
     (
         TFLayoutLMModel,
         TFLayoutLMForMaskedLM,
         TFLayoutLMForTokenClassification,
         TFLayoutLMForSequenceClassification,
         TFLayoutLMForQuestionAnswering,
     )
     if is_tf_available()
     else ()
 )
 __lowerCamelCase					: Any    = (
     {
         'feature-extraction': TFLayoutLMModel,
         'fill-mask': TFLayoutLMForMaskedLM,
         'text-classification': TFLayoutLMForSequenceClassification,
         'token-classification': TFLayoutLMForTokenClassification,
         'zero-shot': TFLayoutLMForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 __lowerCamelCase					: Any    = False
 __lowerCamelCase					: List[Any]    = True
 __lowerCamelCase					: Any    = 10



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


      """simple docstring"""



      _a											=						TFLayoutLMModelTester(self )
      _a											=						ConfigTester(self				,     config_class=A				,     hidden_size=37 )



 def       a__						(self )					->  Any:


      """simple docstring"""



      self.config_tester.run_common_tests()



 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A )



 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*A )



 def       a__						(self )					->  Optional[Any]:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*A )



 def       a__						(self )					->  str:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*A )



 def       a__						(self )					->  int:


      """simple docstring"""



      _a											=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*A )



 @slow
 def       a__						(self )					->  List[str]:


      """simple docstring"""



      for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _a											=						TFLayoutLMModel.from_pretrained(A )
           self.assertIsNotNone(A )



 @unittest.skip('''Onnx compliancy broke with TF 2.10''' )
 def       a__						(self )					->  Union[str, Any]:


      """simple docstring"""



      pass





def lowerCAmelCase						():



     """simple docstring"""



     _a											=						tf.convert_to_tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]])  # noqa: E231
     _a											=						tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],])  # noqa: E231
     _a											=						tf.convert_to_tensor([[[0,0,0,0],[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],[1_000,1_000,1_000,1_000]],[[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],[1_000,1_000,1_000,1_000]]])  # noqa: E231
     _a											=						tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]])  # noqa: E231
     # these are sequence labels (i.e. at the token level)
     _a											=						tf.convert_to_tensor([[-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		):



 '''simple docstring'''







 @slow
 def       a__						(self )					->  Union[str, Any]:


      """simple docstring"""



      _a											=						TFLayoutLMModel.from_pretrained('''microsoft/layoutlm-base-uncased''' )

      _a						,					_a						,					_a						,					_a						,					_a											=						prepare_layoutlm_batch_inputs()

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

      # test the sequence output on [0, :3, :3]
      _a											=						tf.convert_to_tensor(
          [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]				,     )

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

      # test the pooled output on [1, :3]
      _a											=						tf.convert_to_tensor([-0.6580, -0.0214, 0.8552] )

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



 @slow
 def       a__						(self )					->  List[Any]:


      """simple docstring"""



      _a											=						TFLayoutLMForSequenceClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''				,     num_labels=2 )

      _a						,					_a						,					_a						,					_a						,					_a											=						prepare_layoutlm_batch_inputs()

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

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

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



 @slow
 def       a__						(self )					->  List[str]:


      """simple docstring"""



      _a											=						TFLayoutLMForTokenClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''				,     num_labels=13 )

      _a						,					_a						,					_a						,					_a						,					_a											=						prepare_layoutlm_batch_inputs()

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

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



 @slow
 def       a__						(self )					->  List[Any]:


      """simple docstring"""



      _a											=						TFLayoutLMForQuestionAnswering.from_pretrained('''microsoft/layoutlm-base-uncased''' )

      _a						,					_a						,					_a						,					_a						,					_a											=						prepare_layoutlm_batch_inputs()

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

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








'''simple docstring'''





import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image

  from transformers import MobileNetVaImageProcessor






class __A    (						unittest.TestCase		):



 '''simple docstring'''







 def __init__(self				,     A				,     A=7				,     A=3				,     A=18				,     A=30				,     A=400				,     A=True				,     A=None				,     A=True				,     A=None				,     )					->  Any:


      """simple docstring"""



      _a											=						size if size is not None else {'''shortest_edge''': 20}
      _a											=						crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
      _a											=						parent
      _a											=						batch_size
      _a											=						num_channels
      _a											=						image_size
      _a											=						min_resolution
      _a											=						max_resolution
      _a											=						do_resize
      _a											=						size
      _a											=						do_center_crop
      _a											=						crop_size



 def       a__						(self )					->  Optional[Any]:


      """simple docstring"""



      return {
          "do_resize": self.do_resize,
          "size": self.size,
          "do_center_crop": self.do_center_crop,
          "crop_size": self.crop_size,
      }






@require_torch
@require_vision
class __A    (						A     ,     unittest.TestCase		):



 '''simple docstring'''







 __lowerCamelCase					: Tuple    = MobileNetVaImageProcessor if is_vision_available() else None



 def       a__						(self )					->  int:


      """simple docstring"""



      _a											=						MobileNetVaImageProcessingTester(self )



 @property
 def       a__						(self )					->  Optional[Any]:


      """simple docstring"""



      return self.image_processor_tester.prepare_image_processor_dict()



 def       a__						(self )					->  str:


      """simple docstring"""



      _a											=						self.image_processing_class(**self.image_processor_dict )
      self.assertTrue(hasattr(A				,     '''do_resize''' ) )
      self.assertTrue(hasattr(A				,     '''size''' ) )
      self.assertTrue(hasattr(A				,     '''do_center_crop''' ) )
      self.assertTrue(hasattr(A				,     '''crop_size''' ) )



 def       a__						(self )					->  Optional[int]:


      """simple docstring"""



      _a											=						self.image_processing_class.from_dict(self.image_processor_dict )
      self.assertEqual(image_processor.size				,     {'''shortest_edge''': 20} )
      self.assertEqual(image_processor.crop_size				,     {'''height''': 18, '''width''': 18} )

      _a											=						self.image_processing_class.from_dict(self.image_processor_dict				,     size=42				,     crop_size=84 )
      self.assertEqual(image_processor.size				,     {'''shortest_edge''': 42} )
      self.assertEqual(image_processor.crop_size				,     {'''height''': 84, '''width''': 84} )



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


      """simple docstring"""



      pass



 def       a__						(self )					->  Any:


      """simple docstring"""



      _a											=						self.image_processing_class(**self.image_processor_dict )
      # create random PIL images
      _a											=						prepare_image_inputs(self.image_processor_tester				,     equal_resolution=A )
      for image in image_inputs:
           self.assertIsInstance(A				,     Image.Image )

      # Test not batched input
      _a											=						image_processing(image_inputs[0]				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )

      # Test batched
      _a											=						image_processing(A				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )



 def       a__						(self )					->  Optional[int]:


      """simple docstring"""



      _a											=						self.image_processing_class(**self.image_processor_dict )
      # create random numpy tensors
      _a											=						prepare_image_inputs(self.image_processor_tester				,     equal_resolution=A				,     numpify=A )
      for image in image_inputs:
           self.assertIsInstance(A				,     np.ndarray )

      # Test not batched input
      _a											=						image_processing(image_inputs[0]				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )

      # Test batched
      _a											=						image_processing(A				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )



 def       a__						(self )					->  Optional[Any]:


      """simple docstring"""



      _a											=						self.image_processing_class(**self.image_processor_dict )
      # create random PyTorch tensors
      _a											=						prepare_image_inputs(self.image_processor_tester				,     equal_resolution=A				,     torchify=A )
      for image in image_inputs:
           self.assertIsInstance(A				,     torch.Tensor )

      # Test not batched input
      _a											=						image_processing(image_inputs[0]				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )

      # Test batched
      _a											=						image_processing(A				,     return_tensors='''pt''' ).pixel_values
      self.assertEqual(
          encoded_images.shape				,     (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size['''height'''],
              self.image_processor_tester.crop_size['''width'''],
          )				,     )



