


'''simple docstring'''







import unittest

from transformers import LayoutLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
  import torch

  from transformers import (
      LayoutLMForMaskedLM,
      LayoutLMForQuestionAnswering,
      LayoutLMForSequenceClassification,
      LayoutLMForTokenClassification,
      LayoutLMModel,
  )
class    lowercase_	:


    def __init__(	self    ,   a    ,   a=13    ,   a=7    ,   a=True    ,   a=True    ,   a=True    ,   a=True    ,   a=99    ,   a=32    ,   a=5    ,   a=4    ,   a=37    ,   a="gelu"    ,   a=0.1    ,   a=0.1    ,   a=5_12    ,   a=16    ,   a=2    ,   a=0.02    ,   a=3    ,   a=4    ,   a=None    ,   a=10_00    ,   ):
          UpperCamelCase__      =							parent
          UpperCamelCase__      =							batch_size
          UpperCamelCase__      =							seq_length
          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__      =							num_labels
          UpperCamelCase__      =							num_choices
          UpperCamelCase__      =							scope
          UpperCamelCase__      =							range_bbox


    def   __a				(	self       ):
          UpperCamelCase__      =							ids_tensor([self.batch_size, self.seq_length]    ,   self.vocab_size       )

          UpperCamelCase__      =							ids_tensor([self.batch_size, self.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]:
                            UpperCamelCase__      =							bbox[i, j, 3]
                            UpperCamelCase__      =							bbox[i, j, 1]
                            UpperCamelCase__      =							t
                      if bbox[i, j, 2] < bbox[i, j, 0]:
                            UpperCamelCase__      =							bbox[i, j, 2]
                            UpperCamelCase__      =							bbox[i, j, 0]
                            UpperCamelCase__      =							t

          UpperCamelCase__      =							None
          if self.use_input_mask:
                UpperCamelCase__      =							ids_tensor([self.batch_size, self.seq_length]    ,   vocab_size=2       )

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

          UpperCamelCase__      =							None
          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.seq_length]    ,   self.num_labels       )
                UpperCamelCase__      =							ids_tensor([self.batch_size]    ,   self.num_choices       )

          UpperCamelCase__      =							self.get_config()

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


    def   __a				(	self       ):
          return 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    ,   )


    def   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a       ):
          UpperCamelCase__      =							LayoutLMModel(config=a       )
          model.to(a       )
          model.eval()
          UpperCamelCase__      =							model(a    ,   a    ,   attention_mask=a    ,   token_type_ids=a       )
          UpperCamelCase__      =							model(a    ,   a    ,   token_type_ids=a       )
          UpperCamelCase__      =							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       ):
          UpperCamelCase__      =							LayoutLMForMaskedLM(config=a       )
          model.to(a       )
          model.eval()
          UpperCamelCase__      =							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       ):
          UpperCamelCase__      =							self.num_labels
          UpperCamelCase__      =							LayoutLMForSequenceClassification(a       )
          model.to(a       )
          model.eval()
          UpperCamelCase__      =							model(
              a    ,   a    ,   attention_mask=a    ,   token_type_ids=a    ,   labels=a       )
          self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_labels)       )


    def   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a       ):
          UpperCamelCase__      =							self.num_labels
          UpperCamelCase__      =							LayoutLMForTokenClassification(config=a       )
          model.to(a       )
          model.eval()
          UpperCamelCase__      =							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       ):
          UpperCamelCase__      =							LayoutLMForQuestionAnswering(config=a       )
          model.to(a       )
          model.eval()
          UpperCamelCase__      =							model(
              a    ,   bbox=a    ,   attention_mask=a    ,   token_type_ids=a    ,   start_positions=a    ,   end_positions=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       ):
          UpperCamelCase__      =							self.prepare_config_and_inputs()
          (
              (
              UpperCamelCase__
          )   ,      (
              UpperCamelCase__
          )   ,      (
              UpperCamelCase__
          )   ,      (
              UpperCamelCase__
          )   ,      (
              UpperCamelCase__
          )   ,      (
              UpperCamelCase__
          )   ,      (
              UpperCamelCase__
          )   ,      (
              UpperCamelCase__
          )   ,      
          )      =							config_and_inputs
          UpperCamelCase__      =							{
              "input_ids": input_ids,
              "bbox": bbox,
              "token_type_ids": token_type_ids,
              "attention_mask": input_mask,
          }
          return config, inputs_dict

@require_torch
class    lowercase_	(       a__    ,		a__    ,		unittest.TestCase  ):
    __UpperCAmelCase       =      (
        (
            LayoutLMModel,
            LayoutLMForMaskedLM,
            LayoutLMForSequenceClassification,
            LayoutLMForTokenClassification,
            LayoutLMForQuestionAnswering,
        )
        if is_torch_available()
        else None
    )
    __UpperCAmelCase       =      (
        {
            'document-question-answering': LayoutLMForQuestionAnswering,
            'feature-extraction': LayoutLMModel,
            'fill-mask': LayoutLMForMaskedLM,
            'text-classification': LayoutLMForSequenceClassification,
            'token-classification': LayoutLMForTokenClassification,
            'zero-shot': LayoutLMForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    __UpperCAmelCase       =      True


    def   __a				(	self       ):
          UpperCamelCase__      =							LayoutLMModelTester(self       )
          UpperCamelCase__      =							ConfigTester(self    ,   config_class=a    ,   hidden_size=37       )


    def   __a				(	self       ):
          self.config_tester.run_common_tests()


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*a       )


    def   __a				(	self       ):
          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(*a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*a       )


    @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."       )
    def   __a				(	self       ):
          pass







def _UpperCamelCase			(	)				->						Dict:


      '''simple docstring'''



      UpperCamelCase__      =							torch.tensor([[101,1019,1014,1016,1037,12849,4747,1004,14246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,11300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,19274,2772,6205,27814,16147,16147,4343,2047,10283,10969,14389,1012,2338,102]] ,     device=__A       )  # noqa: E231
      UpperCamelCase__      =							torch.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],] ,     device=__A       )  # noqa: E231
      UpperCamelCase__      =							torch.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],[1000,1000,1000,1000]],[[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],[1000,1000,1000,1000]]] ,     device=__A       )  # noqa: E231
      UpperCamelCase__      =							torch.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]] ,     device=__A       )  # noqa: E231
      # these are sequence labels (i.e. at the token level)
      UpperCamelCase__      =							torch.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]] ,     device=__A       )  # noqa: E231
      # fmt: on

      return input_ids, attention_mask, bbox, token_type_ids, labels



@require_torch
class    lowercase_	(       unittest.TestCase  ):


    @slow
    def   __a				(	self       ):
          UpperCamelCase__      =							LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"       ).to(a       )

          UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__      =							prepare_layoutlm_batch_inputs()

          # forward pass
          UpperCamelCase__      =							model(input_ids=a    ,   bbox=a    ,   attention_mask=a    ,   token_type_ids=a       )

          # test the sequence output on [0, :3, :3]
          UpperCamelCase__      =							torch.tensor(
              [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]    ,   device=a    ,   )

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

          # test the pooled output on [1, :3]
          UpperCamelCase__      =							torch.tensor([-0.6580, -0.0214, 0.8552]    ,   device=a       )

          self.assertTrue(torch.allclose(outputs.pooler_output[1, :3]    ,   a    ,   atol=1e-3       )       )


    @slow
    def   __a				(	self       ):
          # initialize model with randomly initialized sequence classification head
          UpperCamelCase__      =							LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,   num_labels=2       ).to(
              a       )

          UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__      =							prepare_layoutlm_batch_inputs()

          # forward pass
          UpperCamelCase__      =							model(
              input_ids=a    ,   bbox=a    ,   attention_mask=a    ,   token_type_ids=a    ,   labels=torch.tensor([1, 1]    ,   device=a       )    ,   )

          # test whether we get a loss as a scalar
          UpperCamelCase__      =							outputs.loss
          UpperCamelCase__      =							torch.Size([]       )
          self.assertEqual(loss.shape    ,   a       )

          # test the shape of the logits
          UpperCamelCase__      =							outputs.logits
          UpperCamelCase__      =							torch.Size((2, 2)       )
          self.assertEqual(logits.shape    ,   a       )


    @slow
    def   __a				(	self       ):
          # initialize model with randomly initialized token classification head
          UpperCamelCase__      =							LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,   num_labels=13       ).to(
              a       )

          UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__      =							prepare_layoutlm_batch_inputs()

          # forward pass
          UpperCamelCase__      =							model(
              input_ids=a    ,   bbox=a    ,   attention_mask=a    ,   token_type_ids=a    ,   labels=a       )

          # test the loss calculation to be around 2.65
          # expected_loss = torch.tensor(2.65, device=torch_device)

          # The loss is currently somewhat random and can vary between 0.1-0.3 atol.
          # self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

          # test the shape of the logits
          UpperCamelCase__      =							outputs.logits
          UpperCamelCase__      =							torch.Size((2, 25, 13)       )
          self.assertEqual(logits.shape    ,   a       )


    @slow
    def   __a				(	self       ):
          # initialize model with randomly initialized token classification head
          UpperCamelCase__      =							LayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"       ).to(a       )

          UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__   ,      UpperCamelCase__      =							prepare_layoutlm_batch_inputs()

          # forward pass
          UpperCamelCase__      =							model(input_ids=a    ,   bbox=a    ,   attention_mask=a    ,   token_type_ids=a       )

          # test the shape of the logits
          UpperCamelCase__      =							torch.Size((2, 25)       )
          self.assertEqual(outputs.start_logits.shape    ,   a       )
          self.assertEqual(outputs.end_logits.shape    ,   a       )









'''simple docstring'''







def _UpperCamelCase			(	__A ,     __A       )				->						int:


      '''simple docstring'''



      return (input_a, input_a).count(0       ) % 2







def _UpperCamelCase			(	)				->						None:


      '''simple docstring'''



      assert xor_gate(0 ,     0       ) == 0
      assert xor_gate(0 ,     1       ) == 1
      assert xor_gate(1 ,     0       ) == 1
      assert xor_gate(1 ,     1       ) == 0


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





