

def  UpperCAmelCase__      ( UpperCAmelCase__,    UpperCAmelCase__			)     ->     int:
       return 1 if input_a == input_a else 0
def  UpperCAmelCase__      ( )     ->     None:
       assert xnor_gate(0,    0			) == 1
       assert xnor_gate(0,    1			) == 0
       assert xnor_gate(1,    0			) == 0
       assert xnor_gate(1,    1			) == 1


if __name__ == "__main__":
      print(xnor_gate(0, 0))
      print(xnor_gate(0, 1))
      print(xnor_gate(1, 0))
      print(xnor_gate(1, 1))



'''simple docstring'''







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    A__ :



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





           '''simple docstring'''
           A_		   = parent
           A_		   = batch_size
           A_		   = num_channels
           A_		   = image_size
           A_		   = patch_size
           A_		   = text_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_		   = 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    snake_case_     (   self    )  -> Any:





           '''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    )
           # 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_		   = 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    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> str:





           '''simple docstring'''
           A_		   = LayoutLMvaModel(config=UpperCamelCase__    )
           model.to(UpperCamelCase__    )
           model.eval()

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



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> Optional[Any]:





           '''simple docstring'''
           A_		   = self.num_labels
           A_		   = LayoutLMvaForSequenceClassification(UpperCamelCase__    )
           model.to(UpperCamelCase__    )
           model.eval()
           A_		   = 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    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> str:





           '''simple docstring'''
           A_		   = self.num_labels
           A_		   = LayoutLMvaForTokenClassification(config=UpperCamelCase__    )
           model.to(UpperCamelCase__    )
           model.eval()
           A_		   = 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    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> int:





           '''simple docstring'''
           A_		   = LayoutLMvaForQuestionAnswering(config=UpperCamelCase__    )
           model.to(UpperCamelCase__    )
           model.eval()
           A_		   = 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    snake_case_     (   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,
               """pixel_values""": pixel_values,
               """token_type_ids""": token_type_ids,
               """attention_mask""": input_mask,
           }
           return config, inputs_dict


@require_torch
class    A__ ( _snake_case  ,  _snake_case  ,  unittest.TestCase     ):
    lowercase		   =						False
    lowercase		   =						False
    lowercase		   =						False

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



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> Dict:





           '''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    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           A_		   = LayoutLMvaModelTester(self    )
           A_		   = ConfigTester(self						,			config_class=UpperCamelCase__						,			hidden_size=37    )



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__=False    )  -> Union[str, Any]:





           '''simple docstring'''
           A_		   = copy.deepcopy(UpperCamelCase__    )
           if model_class in get_values(UpperCamelCase__    ):
                  A_		   = {
                      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__    ):
                         A_		   = torch.ones(self.model_tester.batch_size						,			dtype=torch.long						,			device=UpperCamelCase__    )
                  elif model_class in get_values(UpperCamelCase__    ):
                         A_		   = torch.zeros(
                             self.model_tester.batch_size						,			dtype=torch.long						,			device=UpperCamelCase__    )
                         A_		   = torch.zeros(
                             self.model_tester.batch_size						,			dtype=torch.long						,			device=UpperCamelCase__    )
                  elif model_class in [
                      *get_values(UpperCamelCase__    ),
                  ]:
                         A_		   = torch.zeros(
                             self.model_tester.batch_size						,			dtype=torch.long						,			device=UpperCamelCase__    )
                  elif model_class in [
                      *get_values(UpperCamelCase__    ),
                  ]:
                         A_		   = torch.zeros(
                             (self.model_tester.batch_size, self.model_tester.text_seq_length)						,			dtype=torch.long						,			device=UpperCamelCase__						,			)

           return inputs_dict



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





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



    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCamelCase__    )



    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           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__    )



    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__    )



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





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__    )



    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           A_		   = self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__    )







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





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

def  UpperCAmelCase__      ( )     ->     Dict:
       A_		   = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
       return image







@require_torch
class    A__ ( unittest.TestCase     ):



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





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







    @slow
    def    snake_case_     (   self    )  -> Optional[Any]:





           '''simple docstring'''
           A_		   = LayoutLMvaModel.from_pretrained("""microsoft/layoutlmv3-base"""    ).to(UpperCamelCase__    )

           A_		   = self.default_image_processor
           A_		   = prepare_img()
           A_		   = image_processor(images=UpperCamelCase__						,			return_tensors="""pt"""    ).pixel_values.to(UpperCamelCase__    )

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

           # forward pass
           A_		   = model(
               input_ids=input_ids.to(UpperCamelCase__    )						,			bbox=bbox.to(UpperCamelCase__    )						,			pixel_values=pixel_values.to(UpperCamelCase__    )						,			)

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

           A_		   = torch.tensor(
               [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]    ).to(UpperCamelCase__    )

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