
"""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 __lowerCAmelCase	:





     def __init__(			self			,  __UpperCAmelCase			,  __UpperCAmelCase=2			,  __UpperCAmelCase=3			,  __UpperCAmelCase=4			,  __UpperCAmelCase=2			,  __UpperCAmelCase=7			,  __UpperCAmelCase=True			,  __UpperCAmelCase=True			,  __UpperCAmelCase=True			,  __UpperCAmelCase=True			,  __UpperCAmelCase=99			,  __UpperCAmelCase=36			,  __UpperCAmelCase=2			,  __UpperCAmelCase=4			,  __UpperCAmelCase=37			,  __UpperCAmelCase="gelu"			,  __UpperCAmelCase=0.1			,  __UpperCAmelCase=0.1			,  __UpperCAmelCase=512			,  __UpperCAmelCase=16			,  __UpperCAmelCase=2			,  __UpperCAmelCase=0.0_2			,  __UpperCAmelCase=6			,  __UpperCAmelCase=6			,  __UpperCAmelCase=3			,  __UpperCAmelCase=4			,  __UpperCAmelCase=None			,  __UpperCAmelCase=1000			,  ):

      '''simple docstring'''




      __UpperCamelCase       						= parent
      __UpperCamelCase       						= batch_size
      __UpperCamelCase       						= num_channels
      __UpperCamelCase       						= image_size
      __UpperCamelCase       						= patch_size
      __UpperCamelCase       						= is_training
      __UpperCamelCase       						= use_input_mask
      __UpperCamelCase       						= use_token_type_ids
      __UpperCamelCase       						= use_labels
      __UpperCamelCase       						= vocab_size
      __UpperCamelCase       						= hidden_size
      __UpperCamelCase       						= num_hidden_layers
      __UpperCamelCase       						= num_attention_heads
      __UpperCamelCase       						= intermediate_size
      __UpperCamelCase       						= hidden_act
      __UpperCamelCase       						= hidden_dropout_prob
      __UpperCamelCase       						= attention_probs_dropout_prob
      __UpperCamelCase       						= max_position_embeddings
      __UpperCamelCase       						= type_vocab_size
      __UpperCamelCase       						= type_sequence_label_size
      __UpperCamelCase       						= initializer_range
      __UpperCamelCase       						= coordinate_size
      __UpperCamelCase       						= shape_size
      __UpperCamelCase       						= num_labels
      __UpperCamelCase       						= num_choices
      __UpperCamelCase       						= scope
      __UpperCamelCase       						= range_bbox

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





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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

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

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

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

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

      __UpperCamelCase       						= None
      __UpperCamelCase       						= None
      if self.use_labels:
       __UpperCamelCase       						= ids_tensor([self.batch_size]			,  self.type_sequence_label_size   )
       __UpperCamelCase       						= ids_tensor([self.batch_size, self.text_seq_length]			,  self.num_labels   )

      __UpperCamelCase       						= 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 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= TFLayoutLMvaModel(config=__UpperCAmelCase   )

      # text + image
      __UpperCamelCase       						= model(__UpperCAmelCase			,  pixel_values=__UpperCAmelCase			,  training=__UpperCAmelCase   )
      __UpperCamelCase       						= model(
          __UpperCAmelCase			,  bbox=__UpperCAmelCase			,  pixel_values=__UpperCAmelCase			,  attention_mask=__UpperCAmelCase			,  token_type_ids=__UpperCAmelCase			,  training=__UpperCAmelCase			,  )
      __UpperCamelCase       						= 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
      __UpperCamelCase       						= model(__UpperCAmelCase			,  training=__UpperCAmelCase   )
      self.parent.assertEqual(
          result.last_hidden_state.shape			,  (self.batch_size, self.text_seq_length, self.hidden_size)   )

      # image only
      __UpperCamelCase       						= 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 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.num_labels
      __UpperCamelCase       						= TFLayoutLMvaForSequenceClassification(config=__UpperCAmelCase   )
      __UpperCamelCase       						= 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 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.num_labels
      __UpperCamelCase       						= TFLayoutLMvaForTokenClassification(config=__UpperCAmelCase   )
      __UpperCamelCase       						= 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 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= 2
      __UpperCamelCase       						= TFLayoutLMvaForQuestionAnswering(config=__UpperCAmelCase   )
      __UpperCamelCase       						= 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 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.prepare_config_and_inputs()
      (__UpperCamelCase)       						= config_and_inputs
      __UpperCamelCase       						= {
          """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 __lowerCAmelCase	(   UpperCAmelCase__    ,						UpperCAmelCase__    ,						unittest.TestCase    ):
     lowercase		     =		(
         (
             TFLayoutLMvaModel,
             TFLayoutLMvaForQuestionAnswering,
             TFLayoutLMvaForSequenceClassification,
             TFLayoutLMvaForTokenClassification,
         )
         if is_tf_available()
         else ()
     )
     lowercase		     =		(
         {'document-question-answering': TFLayoutLMvaForQuestionAnswering, 'feature-extraction': TFLayoutLMvaModel}
         if is_tf_available()
         else {}
     )

     lowercase		     =		False
     lowercase		     =		False
     lowercase		     =		False





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




      return True





     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase=False   ):

      '''simple docstring'''




      __UpperCamelCase       						= copy.deepcopy(__UpperCAmelCase   )

      if model_class in get_values(__UpperCAmelCase   ):
       __UpperCamelCase       						= {
           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   ):
        __UpperCamelCase       						= tf.ones(self.model_tester.batch_size			,  dtype=tf.intaa   )
       elif model_class in get_values(__UpperCAmelCase   ):
        __UpperCamelCase       						= tf.zeros(self.model_tester.batch_size			,  dtype=tf.intaa   )
        __UpperCamelCase       						= tf.zeros(self.model_tester.batch_size			,  dtype=tf.intaa   )
       elif model_class in get_values(__UpperCAmelCase   ):
        __UpperCamelCase       						= tf.zeros(self.model_tester.batch_size			,  dtype=tf.intaa   )
       elif model_class in get_values(__UpperCAmelCase   ):
        __UpperCamelCase       						= tf.zeros(
            (self.model_tester.batch_size, self.model_tester.text_seq_length)			,  dtype=tf.intaa   )

      return inputs_dict





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= TFLayoutLMvaModelTester(self   )
      __UpperCamelCase       						= ConfigTester(self			,  config_class=__UpperCAmelCase			,  hidden_size=37   )





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      self.config_tester.run_common_tests()





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes:
       __UpperCamelCase       						= 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
        __UpperCamelCase       						= self._prepare_for_class(inputs_dict.copy()			,  __UpperCAmelCase			,  return_labels=__UpperCAmelCase   )
        __UpperCamelCase       						= prepared_for_class[
            sorted(prepared_for_class.keys() - inputs_dict.keys()			,  reverse=__UpperCAmelCase   )[0]
        ]
        __UpperCamelCase       						= added_label.shape.as_list()[:1]

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

        __UpperCamelCase       						= 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
        __UpperCamelCase       						= self._prepare_for_class(inputs_dict.copy()			,  __UpperCAmelCase			,  return_labels=__UpperCAmelCase   )
        __UpperCamelCase       						= prepared_for_class.pop('input_ids'   )
        if "labels" in prepared_for_class:
         __UpperCamelCase       						= prepared_for_class["""labels"""].numpy()
         if len(labels.shape   ) > 1 and labels.shape[1] != 1:
          __UpperCamelCase       						= -100
          __UpperCamelCase       						= tf.convert_to_tensor(__UpperCAmelCase   )
          __UpperCamelCase       						= 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
        __UpperCamelCase       						= self._prepare_for_class(inputs_dict.copy()			,  __UpperCAmelCase			,  return_labels=__UpperCAmelCase   )
        __UpperCamelCase       						= 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
        __UpperCamelCase       						= self._prepare_for_class(inputs_dict.copy()			,  __UpperCAmelCase			,  return_labels=__UpperCAmelCase   )

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

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

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

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

        __UpperCamelCase       						= tuple(__UpperCAmelCase   )

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

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





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      (
          __UpperCamelCase		
      )       						= 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 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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






def 							A		(       )   ->			Optional[Any]:
 __UpperCamelCase       						= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
 return image





@require_tf
class __lowerCAmelCase	(   unittest.TestCase    ):





     @cached_property
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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







     @slow
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= TFLayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'   )

      __UpperCamelCase       						= self.default_image_processor
      __UpperCamelCase       						= prepare_img()
      __UpperCamelCase       						= image_processor(images=__UpperCAmelCase			,  return_tensors='tf'   ).pixel_values

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

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

      # verify the logits
      __UpperCamelCase       						= (1, 199, 768)
      self.assertEqual(outputs.last_hidden_state.shape			,  __UpperCAmelCase   )

      __UpperCamelCase       						= 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 typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCamelCase			:       List[str]									=				{
    "configuration_autoformer": [
        "AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "AutoformerConfig",
    ],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase			:       Dict									=				[
          "AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "AutoformerForPrediction",
          "AutoformerModel",
          "AutoformerPreTrainedModel",
      ]


if TYPE_CHECKING:
      from .configuration_autoformer import (
          AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
          AutoformerConfig,
      )

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_autoformer import (
                AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
                AutoformerForPrediction,
                AutoformerModel,
                AutoformerPreTrainedModel,
            )

else:
      import sys

      UpperCamelCase			:       int									=				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



