



import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      LayoutLMvaConfig,
      LayoutLMvaForQuestionAnswering,
      LayoutLMvaForSequenceClassification,
      LayoutLMvaForTokenClassification,
      LayoutLMvaModel,
  )
  from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

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=3						,					__UpperCAmelCase=4						,					__UpperCAmelCase=37						,					__UpperCAmelCase="gelu"						,					__UpperCAmelCase=0.1						,					__UpperCAmelCase=0.1						,					__UpperCAmelCase=512						,					__UpperCAmelCase=16						,					__UpperCAmelCase=2						,					__UpperCAmelCase=0.02						,					__UpperCAmelCase=6						,					__UpperCAmelCase=6						,					__UpperCAmelCase=3						,					__UpperCAmelCase=4						,					__UpperCAmelCase=None						,					__UpperCAmelCase=1000						,					):



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

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




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     ids_tensor([self.batch_size, self.text_seq_length]						,					self.vocab_size					)

    __lowerCamelCase    				=     ids_tensor([self.batch_size, self.text_seq_length, 4]						,					self.range_bbox					)
    # 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]:
             __lowerCamelCase    				=     bbox[i, j, 3]
             __lowerCamelCase    				=     bbox[i, j, 1]
             __lowerCamelCase    				=     t
          if bbox[i, j, 2] < bbox[i, j, 0]:
             __lowerCamelCase    				=     bbox[i, j, 2]
             __lowerCamelCase    				=     bbox[i, j, 0]
             __lowerCamelCase    				=     t

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

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

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

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

    __lowerCamelCase    				=     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 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     LayoutLMvaModel(config=__UpperCAmelCase					)
    model.to(__UpperCAmelCase					)
    model.eval()

    # text + image
    __lowerCamelCase    				=     model(__UpperCAmelCase						,					pixel_values=__UpperCAmelCase					)
    __lowerCamelCase    				=     model(
        __UpperCAmelCase						,					bbox=__UpperCAmelCase						,					pixel_values=__UpperCAmelCase						,					attention_mask=__UpperCAmelCase						,					token_type_ids=__UpperCAmelCase					)
    __lowerCamelCase    				=     model(__UpperCAmelCase						,					bbox=__UpperCAmelCase						,					pixel_values=__UpperCAmelCase						,					token_type_ids=__UpperCAmelCase					)
    __lowerCamelCase    				=     model(__UpperCAmelCase						,					bbox=__UpperCAmelCase						,					pixel_values=__UpperCAmelCase					)

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

    # text only
    __lowerCamelCase    				=     model(__UpperCAmelCase					)
    self.parent.assertEqual(
        result.last_hidden_state.shape						,					(self.batch_size, self.text_seq_length, self.hidden_size)					)

    # image only
    __lowerCamelCase    				=     model(pixel_values=__UpperCAmelCase					)
    self.parent.assertEqual(
        result.last_hidden_state.shape						,					(self.batch_size, self.image_seq_length, self.hidden_size)					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.num_labels
    __lowerCamelCase    				=     LayoutLMvaForSequenceClassification(__UpperCAmelCase					)
    model.to(__UpperCAmelCase					)
    model.eval()
    __lowerCamelCase    				=     model(
        __UpperCAmelCase						,					bbox=__UpperCAmelCase						,					pixel_values=__UpperCAmelCase						,					attention_mask=__UpperCAmelCase						,					token_type_ids=__UpperCAmelCase						,					labels=__UpperCAmelCase						,					)
    self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.num_labels)					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.num_labels
    __lowerCamelCase    				=     LayoutLMvaForTokenClassification(config=__UpperCAmelCase					)
    model.to(__UpperCAmelCase					)
    model.eval()
    __lowerCamelCase    				=     model(
        __UpperCAmelCase						,					bbox=__UpperCAmelCase						,					pixel_values=__UpperCAmelCase						,					attention_mask=__UpperCAmelCase						,					token_type_ids=__UpperCAmelCase						,					labels=__UpperCAmelCase						,					)
    self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.text_seq_length, self.num_labels)					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     LayoutLMvaForQuestionAnswering(config=__UpperCAmelCase					)
    model.to(__UpperCAmelCase					)
    model.eval()
    __lowerCamelCase    				=     model(
        __UpperCAmelCase						,					bbox=__UpperCAmelCase						,					pixel_values=__UpperCAmelCase						,					attention_mask=__UpperCAmelCase						,					token_type_ids=__UpperCAmelCase						,					start_positions=__UpperCAmelCase						,					end_positions=__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 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.prepare_config_and_inputs()
    (
        (
        __lowerCamelCase
    )				,(
        __lowerCamelCase
    )				,(
        __lowerCamelCase
    )				,(
        __lowerCamelCase
    )				,(
        __lowerCamelCase
    )				,(
        __lowerCamelCase
    )				,(
        __lowerCamelCase
    )				,(
        __lowerCamelCase
    )				,
    )    				=     config_and_inputs
    __lowerCamelCase    				=     {
        '''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_torch
class 			__lowerCAmelCase  (						lowerCAmelCase__	,						lowerCAmelCase__	,						unittest.TestCase ):
 lowerCAmelCase__							       =	False
 lowerCAmelCase__							       =	False
 lowerCAmelCase__							       =	False

 lowerCAmelCase__							       =	(
     (
         LayoutLMvaModel,
         LayoutLMvaForSequenceClassification,
         LayoutLMvaForTokenClassification,
         LayoutLMvaForQuestionAnswering,
     )
     if is_torch_available()
     else ()
 )
 lowerCAmelCase__							       =	(
     {"""document-question-answering""": LayoutLMvaForQuestionAnswering, """feature-extraction""": LayoutLMvaModel}
     if is_torch_available()
     else {}
 )




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    # `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
    # embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
    # the sequence dimension of the text embedding only.
    # (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
    return True




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     LayoutLMvaModelTester(self					)
    __lowerCamelCase    				=     ConfigTester(self						,					config_class=__UpperCAmelCase						,					hidden_size=37					)




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



    '''simple docstring'''
    __lowerCamelCase    				=     copy.deepcopy(__UpperCAmelCase					)
    if model_class in get_values(__UpperCAmelCase					):
       __lowerCamelCase    				=     {
           k: v.unsqueeze(1					).expand(-1						,					self.model_tester.num_choices						,					-1					).contiguous()
           if isinstance(__UpperCAmelCase						,					torch.Tensor					) and v.ndim > 1
           else v
           for k, v in inputs_dict.items()
       }
    if return_labels:
       if model_class in get_values(__UpperCAmelCase					):
          __lowerCamelCase    				=     torch.ones(self.model_tester.batch_size						,					dtype=torch.long						,					device=__UpperCAmelCase					)
       elif model_class in get_values(__UpperCAmelCase					):
          __lowerCamelCase    				=     torch.zeros(
              self.model_tester.batch_size						,					dtype=torch.long						,					device=__UpperCAmelCase					)
          __lowerCamelCase    				=     torch.zeros(
              self.model_tester.batch_size						,					dtype=torch.long						,					device=__UpperCAmelCase					)
       elif model_class in [
           *get_values(__UpperCAmelCase					),
       ]:
          __lowerCamelCase    				=     torch.zeros(
              self.model_tester.batch_size						,					dtype=torch.long						,					device=__UpperCAmelCase					)
       elif model_class in [
           *get_values(__UpperCAmelCase					),
       ]:
          __lowerCamelCase    				=     torch.zeros(
              (self.model_tester.batch_size, self.model_tester.text_seq_length)						,					dtype=torch.long						,					device=__UpperCAmelCase						,					)

    return inputs_dict




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    self.config_tester.run_common_tests()




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    for type in ["absolute", "relative_key", "relative_key_query"]:
       __lowerCamelCase    				=     type
       self.model_tester.create_and_check_model(*__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_sequence_classification(*__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_token_classification(*__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_question_answering(*__UpperCAmelCase					)




 @slow
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __lowerCamelCase    				=     LayoutLMvaModel.from_pretrained(__UpperCAmelCase					)
       self.assertIsNotNone(__UpperCAmelCase					)





def 		a__      (		):
   __lowerCamelCase    				=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
   return image





@require_torch
class 			__lowerCAmelCase  (						unittest.TestCase ):




 @cached_property
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    return LayoutLMvaImageProcessor(apply_ocr=__UpperCAmelCase					) if is_vision_available() else None




 @slow
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''					).to(__UpperCAmelCase					)

    __lowerCamelCase    				=     self.default_image_processor
    __lowerCamelCase    				=     prepare_img()
    __lowerCamelCase    				=     image_processor(images=__UpperCAmelCase						,					return_tensors='''pt'''					).pixel_values.to(__UpperCAmelCase					)

    __lowerCamelCase    				=     torch.tensor([[1, 2]]					)
    __lowerCamelCase    				=     torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]					).unsqueeze(0					)

    # forward pass
    __lowerCamelCase    				=     model(
        input_ids=input_ids.to(__UpperCAmelCase					)						,					bbox=bbox.to(__UpperCAmelCase					)						,					pixel_values=pixel_values.to(__UpperCAmelCase					)						,					)

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

    __lowerCamelCase    				=     torch.tensor(
        [[-0.0_529, 0.3_618, 0.1_632], [-0.1_587, -0.1_667, -0.0_400], [-0.1_557, -0.1_671, -0.0_505]]					).to(__UpperCAmelCase					)

    self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]						,					__UpperCAmelCase						,					atol=1E-4					)					)











import math





def 		a__      (		_UpperCamelCase      :			float			,_UpperCamelCase      :			float				):
   if (
       not isinstance(_UpperCamelCase			,(int, float)				)
       or power_factor < -1
       or power_factor > 1
   ):
      raise ValueError('''power_factor must be a valid float value between -1 and 1.'''				)
   return apparent_power * power_factor





def 		a__      (		_UpperCamelCase      :			float			,_UpperCamelCase      :			float				):
   if (
       not isinstance(_UpperCamelCase			,(int, float)				)
       or power_factor < -1
       or power_factor > 1
   ):
      raise ValueError('''power_factor must be a valid float value between -1 and 1.'''				)
   return apparent_power * math.sqrt(1 - power_factor**2				)


if __name__ == "__main__":
  import doctest

  doctest.testmod()






