



'''simple docstring'''


from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
      TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      LayoutLMvaConfig,
      TFLayoutLMvaForQuestionAnswering,
      TFLayoutLMvaForSequenceClassification,
      TFLayoutLMvaForTokenClassification,
      TFLayoutLMvaModel,
  )

if is_vision_available():
  from PIL import Image

  from transformers import LayoutLMvaImageProcessor







class 	UpperCAmelCase	:


 '''simple docstring'''




 def __init__(   self							,  lowerCAmelCase_							,  lowerCAmelCase_=2							,  lowerCAmelCase_=3							,  lowerCAmelCase_=4							,  lowerCAmelCase_=2							,  lowerCAmelCase_=7							,  lowerCAmelCase_=True							,  lowerCAmelCase_=True							,  lowerCAmelCase_=True							,  lowerCAmelCase_=True							,  lowerCAmelCase_=9_9							,  lowerCAmelCase_=3_6							,  lowerCAmelCase_=2							,  lowerCAmelCase_=4							,  lowerCAmelCase_=3_7							,  lowerCAmelCase_="gelu"							,  lowerCAmelCase_=0.1							,  lowerCAmelCase_=0.1							,  lowerCAmelCase_=5_1_2							,  lowerCAmelCase_=1_6							,  lowerCAmelCase_=2							,  lowerCAmelCase_=0.0_2							,  lowerCAmelCase_=6							,  lowerCAmelCase_=6							,  lowerCAmelCase_=3							,  lowerCAmelCase_=4							,  lowerCAmelCase_=None							,  lowerCAmelCase_=1_0_0_0							,  ) ->      Tuple:



      """simple docstring"""







      a_       		=parent
      a_       		=batch_size
      a_       		=num_channels
      a_       		=image_size
      a_       		=patch_size
      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_       		=coordinate_size
      a_       		=shape_size
      a_       		=num_labels
      a_       		=num_choices
      a_       		=scope
      a_       		=range_bbox

      # LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
      a_       		=text_seq_length
      a_       		=(image_size // patch_size) ** 2 + 1
      a_       		=self.text_seq_length + self.image_seq_length




 def       lowercase_  (   self) ->      Tuple:



      """simple docstring"""







      a_       		=ids_tensor([self.batch_size, self.text_seq_length]							,  self.vocab_size)

      a_       		=ids_tensor([self.batch_size, self.text_seq_length, 4]							,  self.range_bbox)
      a_       		=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_       		=tmp_coordinate
                if bbox[i, j, 2] < bbox[i, j, 0]:
                     a_       		=bbox[i, j, 2]
                     a_       		=bbox[i, j, 0]
                     a_       		=tmp_coordinate
      a_       		=tf.constant(__UpperCamelCase)

      a_       		=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

      a_       		=None
      if self.use_input_mask:
           a_       		=random_attention_mask([self.batch_size, self.text_seq_length])

      a_       		=None
      if self.use_token_type_ids:
           a_       		=ids_tensor([self.batch_size, self.text_seq_length]							,  self.type_vocab_size)

      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.text_seq_length]							,  self.num_labels)

      a_       		=LayoutLMvaConfig(
          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							,  coordinate_size=self.coordinate_size							,  shape_size=self.shape_size							,  input_size=self.image_size							,  patch_size=self.patch_size							,  )

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




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Optional[int]:



      """simple docstring"""







      a_       		=TFLayoutLMvaModel(config=__UpperCamelCase)

      # text + image
      a_       		=model(__UpperCamelCase							,  pixel_values=__UpperCamelCase							,  training=__UpperCamelCase)
      a_       		=model(
          __UpperCamelCase							,  bbox=__UpperCamelCase							,  pixel_values=__UpperCamelCase							,  attention_mask=__UpperCamelCase							,  token_type_ids=__UpperCamelCase							,  training=__UpperCamelCase							,  )
      a_       		=model(__UpperCamelCase							,  bbox=__UpperCamelCase							,  pixel_values=__UpperCamelCase							,  training=__UpperCamelCase)

      self.parent.assertEqual(result.last_hidden_state.shape							,  (self.batch_size, self.seq_length, self.hidden_size))

      # text only
      a_       		=model(__UpperCamelCase							,  training=__UpperCamelCase)
      self.parent.assertEqual(
          result.last_hidden_state.shape							,  (self.batch_size, self.text_seq_length, self.hidden_size))

      # image only
      a_       		=model({"pixel_values": pixel_values}							,  training=__UpperCamelCase)
      self.parent.assertEqual(
          result.last_hidden_state.shape							,  (self.batch_size, self.image_seq_length, self.hidden_size))




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Optional[int]:



      """simple docstring"""







      a_       		=self.num_labels
      a_       		=TFLayoutLMvaForSequenceClassification(config=__UpperCamelCase)
      a_       		=model(
          __UpperCamelCase							,  bbox=__UpperCamelCase							,  pixel_values=__UpperCamelCase							,  attention_mask=__UpperCamelCase							,  token_type_ids=__UpperCamelCase							,  labels=__UpperCamelCase							,  training=__UpperCamelCase							,  )
      self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.num_labels))




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      str:



      """simple docstring"""







      a_       		=self.num_labels
      a_       		=TFLayoutLMvaForTokenClassification(config=__UpperCamelCase)
      a_       		=model(
          __UpperCamelCase							,  bbox=__UpperCamelCase							,  pixel_values=__UpperCamelCase							,  attention_mask=__UpperCamelCase							,  token_type_ids=__UpperCamelCase							,  labels=__UpperCamelCase							,  training=__UpperCamelCase							,  )
      self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.text_seq_length, self.num_labels))




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      str:



      """simple docstring"""







      a_       		=2
      a_       		=TFLayoutLMvaForQuestionAnswering(config=__UpperCamelCase)
      a_       		=model(
          __UpperCamelCase							,  bbox=__UpperCamelCase							,  pixel_values=__UpperCamelCase							,  attention_mask=__UpperCamelCase							,  token_type_ids=__UpperCamelCase							,  start_positions=__UpperCamelCase							,  end_positions=__UpperCamelCase							,  training=__UpperCamelCase							,  )
      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) ->      Union[str, Any]:



      """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,
          "pixel_values": pixel_values,
          "token_type_ids": token_type_ids,
          "attention_mask": input_mask,
      }
      return config, inputs_dict







@require_tf
class 	UpperCAmelCase	(		__a					,	__a					,	unittest.TestCase):


 '''simple docstring'''




 __magic_name__					: Optional[Any]  =      (
     (
         TFLayoutLMvaModel,
         TFLayoutLMvaForQuestionAnswering,
         TFLayoutLMvaForSequenceClassification,
         TFLayoutLMvaForTokenClassification,
     )
     if is_tf_available()
     else ()
 )
 __magic_name__					: List[Any]  =      (
     {"document-question-answering": TFLayoutLMvaForQuestionAnswering, "feature-extraction": TFLayoutLMvaModel}
     if is_tf_available()
     else {}
 )

 __magic_name__					: Dict  =      False
 __magic_name__					: int  =      False
 __magic_name__					: List[Any]  =      False




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      List[Any]:



      """simple docstring"""







      return True




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_=False) ->      dict:



      """simple docstring"""







      a_       		=copy.deepcopy(__UpperCamelCase)

      if model_class in get_values(__UpperCamelCase):
           a_       		={
               k: tf.tile(tf.expand_dims(__UpperCamelCase							,  1)							,  (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1))
               if isinstance(__UpperCamelCase							,  tf.Tensor) and v.ndim > 0
               else v
               for k, v in inputs_dict.items()
           }

      if return_labels:
           if model_class in get_values(__UpperCamelCase):
                a_       		=tf.ones(self.model_tester.batch_size							,  dtype=tf.intaa)
           elif model_class in get_values(__UpperCamelCase):
                a_       		=tf.zeros(self.model_tester.batch_size							,  dtype=tf.intaa)
                a_       		=tf.zeros(self.model_tester.batch_size							,  dtype=tf.intaa)
           elif model_class in get_values(__UpperCamelCase):
                a_       		=tf.zeros(self.model_tester.batch_size							,  dtype=tf.intaa)
           elif model_class in get_values(__UpperCamelCase):
                a_       		=tf.zeros(
                    (self.model_tester.batch_size, self.model_tester.text_seq_length)							,  dtype=tf.intaa)

      return inputs_dict




 def       lowercase_  (   self) ->      List[str]:



      """simple docstring"""







      a_       		=TFLayoutLMvaModelTester(self)
      a_       		=ConfigTester(self							,  config_class=__UpperCamelCase							,  hidden_size=3_7)




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



      """simple docstring"""







      self.config_tester.run_common_tests()




 def       lowercase_  (   self) ->      List[Any]:



      """simple docstring"""







      a_		,						a_       		=self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes:
           a_       		=model_class(__UpperCamelCase)
           if getattr(__UpperCamelCase							,  "hf_compute_loss"							,  __UpperCamelCase):
                # The number of elements in the loss should be the same as the number of elements in the label
                a_       		=self._prepare_for_class(inputs_dict.copy()							,  __UpperCamelCase							,  return_labels=__UpperCamelCase)
                a_       		=prepared_for_class[
                    sorted(prepared_for_class.keys() - inputs_dict.keys()							,  reverse=__UpperCamelCase)[0]
                ]
                a_       		=added_label.shape.as_list()[:1]

                # Test that model correctly compute the loss with kwargs
                a_       		=self._prepare_for_class(inputs_dict.copy()							,  __UpperCamelCase							,  return_labels=__UpperCamelCase)
                a_       		=prepared_for_class.pop("input_ids")

                a_       		=model(__UpperCamelCase							,  **__UpperCamelCase)[0]
                self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])

                # Test that model correctly compute the loss when we mask some positions
                a_       		=self._prepare_for_class(inputs_dict.copy()							,  __UpperCamelCase							,  return_labels=__UpperCamelCase)
                a_       		=prepared_for_class.pop("input_ids")
                if "labels" in prepared_for_class:
                     a_       		=prepared_for_class["labels"].numpy()
                     if len(labels.shape) > 1 and labels.shape[1] != 1:
                          a_       		=-1_0_0
                          a_       		=tf.convert_to_tensor(__UpperCamelCase)
                          a_       		=model(__UpperCamelCase							,  **__UpperCamelCase)[0]
                          self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])
                          self.assertTrue(not np.any(np.isnan(loss.numpy())))

                # Test that model correctly compute the loss with a dict
                a_       		=self._prepare_for_class(inputs_dict.copy()							,  __UpperCamelCase							,  return_labels=__UpperCamelCase)
                a_       		=model(__UpperCamelCase)[0]
                self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])

                # Test that model correctly compute the loss with a tuple
                a_       		=self._prepare_for_class(inputs_dict.copy()							,  __UpperCamelCase							,  return_labels=__UpperCamelCase)

                # Get keys that were added with the _prepare_for_class function
                a_       		=prepared_for_class.keys() - inputs_dict.keys()
                a_       		=inspect.signature(model.call).parameters
                a_       		=list(signature.keys())

                # Create a dictionary holding the location of the tensors in the tuple
                a_       		={0: "input_ids"}
                for label_key in label_keys:
                     a_       		=signature_names.index(__UpperCamelCase)
                     a_       		=label_key
                a_       		=sorted(tuple_index_mapping.items())
                # Initialize a list with their default values, update the values and convert to a tuple
                a_       		=[]

                for name in signature_names:
                     if name != "kwargs":
                          list_input.append(signature[name].default)

                for index, value in sorted_tuple_index_mapping:
                     a_       		=prepared_for_class[value]

                a_       		=tuple(__UpperCamelCase)

                # Send to model
                a_       		=model(tuple_input[:-1])[0]

                self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1])




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



      """simple docstring"""







      (
          (
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,												
      )       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(__UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase)




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



      """simple docstring"""







      (
          (
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,												
      )       		=self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
           a_       		=type
           self.model_tester.create_and_check_model(__UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase)




 def       lowercase_  (   self) ->      int:



      """simple docstring"""







      (
          (
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,												
      )       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(
          __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase)




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



      """simple docstring"""







      (
          (
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,												
      )       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(
          __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase)




 def       lowercase_  (   self) ->      List[Any]:



      """simple docstring"""







      (
          (
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,						(
          a_						
      )		,												
      )       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(
          __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase							,  __UpperCamelCase)




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



      """simple docstring"""







      for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           a_       		=TFLayoutLMvaModel.from_pretrained(__UpperCamelCase)
           self.assertIsNotNone(__UpperCamelCase)






def  UpperCAmelCase_       (		):


     '''simple docstring'''







     a_       		=Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
     return image







@require_tf
class 	UpperCAmelCase	(		unittest.TestCase):


 '''simple docstring'''




 @cached_property
 def       lowercase_  (   self) ->      List[Any]:



      """simple docstring"""







      return LayoutLMvaImageProcessor(apply_ocr=__UpperCamelCase) if is_vision_available() else None




 @slow
 def       lowercase_  (   self) ->      str:



      """simple docstring"""







      a_       		=TFLayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base")

      a_       		=self.default_image_processor
      a_       		=prepare_img()
      a_       		=image_processor(images=__UpperCamelCase							,  return_tensors="tf").pixel_values

      a_       		=tf.constant([[1, 2]])
      a_       		=tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]])							,  axis=0)

      # forward pass
      a_       		=model(input_ids=__UpperCamelCase							,  bbox=__UpperCamelCase							,  pixel_values=__UpperCamelCase							,  training=__UpperCamelCase)

      # verify the logits
      a_       		=(1, 1_9_9, 7_6_8)
      self.assertEqual(outputs.last_hidden_state.shape							,  __UpperCamelCase)

      a_       		=tf.constant(
          [[-0.0_5_2_9, 0.3_6_1_8, 0.1_6_3_2], [-0.1_5_8_7, -0.1_6_6_7, -0.0_4_0_0], [-0.1_5_5_7, -0.1_6_7_1, -0.0_5_0_5]])

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







'''simple docstring'''


from .testing import (
    are_the_same_tensors,
    execute_subprocess_async,
    require_bnb,
    require_cpu,
    require_cuda,
    require_huggingface_suite,
    require_mps,
    require_multi_gpu,
    require_multi_xpu,
    require_safetensors,
    require_single_gpu,
    require_single_xpu,
    require_torch_min_version,
    require_tpu,
    require_xpu,
    skip,
    slow,
)
from .training import RegressionDataset, RegressionModel, RegressionModelaXPU


from .scripts import test_script, test_sync, test_ops  # isort: skip


