






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





    def __init__(				self      :   List[Any]							,						A      :   str							,						A      :   Optional[Any]=1_3							,						A      :   List[Any]=7							,						A      :   int=True							,						A      :   Optional[Any]=True							,						A      :   Tuple=True							,						A      :   Optional[int]=True							,						A      :   Dict=9_9							,						A      :   List[str]=3_2							,						A      :   Union[str, Any]=5							,						A      :   Optional[int]=4							,						A      :   Tuple=3_7							,						A      :   Any="gelu"							,						A      :   int=0.1							,						A      :   str=0.1							,						A      :   List[Any]=5_1_2							,						A      :   Tuple=1_6							,						A      :   str=2							,						A      :   Tuple=0.02							,						A      :   Any=3							,						A      :   Optional[int]=4							,						A      :   List[Any]=None							,						A      :   Optional[int]=1_0_0_0							,						):


      '''simple docstring'''




      a	:     Tuple							=  parent
      a	:     Union[str, Any]							=  batch_size
      a	:     List[str]							=  seq_length
      a	:     str							=  is_training
      a	:     int							=  use_input_mask
      a	:     Dict							=  use_token_type_ids
      a	:     List[Any]							=  use_labels
      a	:     Dict							=  vocab_size
      a	:     int							=  hidden_size
      a	:     Optional[Any]							=  num_hidden_layers
      a	:     List[Any]							=  num_attention_heads
      a	:     Dict							=  intermediate_size
      a	:     Union[str, Any]							=  hidden_act
      a	:     int							=  hidden_dropout_prob
      a	:     Union[str, Any]							=  attention_probs_dropout_prob
      a	:     Optional[Any]							=  max_position_embeddings
      a	:     Dict							=  type_vocab_size
      a	:     List[Any]							=  type_sequence_label_size
      a	:     Union[str, Any]							=  initializer_range
      a	:     Dict							=  num_labels
      a	:     Tuple							=  num_choices
      a	:     Tuple							=  scope
      a	:     Any							=  range_bbox





    def 							lowerCamelCase__ (				self      :   List[str]     ):


      '''simple docstring'''




      a	:     Optional[int]							=  ids_tensor([self.batch_size, self.seq_length]							,						self.vocab_size     )

      a	:     int							=  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]:
            a	:     List[str]							=  bbox[i, j, 3]
            a	:     List[Any]							=  bbox[i, j, 1]
            a	:     Optional[Any]							=  t
          if bbox[i, j, 2] < bbox[i, j, 0]:
            a	:     List[str]							=  bbox[i, j, 2]
            a	:     Dict							=  bbox[i, j, 0]
            a	:     Any							=  t

      a	:     Optional[Any]							=  None
      if self.use_input_mask:
        a	:     List[str]							=  ids_tensor([self.batch_size, self.seq_length]							,						vocab_size=2     )

      a	:     Union[str, Any]							=  None
      if self.use_token_type_ids:
        a	:     Optional[int]							=  ids_tensor([self.batch_size, self.seq_length]							,						self.type_vocab_size     )

      a	:     Optional[int]							=  None
      a	:     int							=  None
      a	:     Optional[int]							=  None
      if self.use_labels:
        a	:     Dict							=  ids_tensor([self.batch_size]							,						self.type_sequence_label_size     )
        a	:     Dict							=  ids_tensor([self.batch_size, self.seq_length]							,						self.num_labels     )
        a	:     List[str]							=  ids_tensor([self.batch_size]							,						self.num_choices     )

      a	:     Any							=  self.get_config()

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





    def 							lowerCamelCase__ (				self      :   Tuple     ):


      '''simple docstring'''




      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 							lowerCamelCase__ (				self      :   Dict							,						A      :   List[str]							,						A      :   List[str]							,						A      :   Dict							,						A      :   Any							,						A      :   Any							,						A      :   Union[str, Any]							,						A      :   List[Any]							,						A      :   Tuple     ):


      '''simple docstring'''




      a	:     Dict							=  LayoutLMModel(config=A     )
      model.to(A     )
      model.eval()
      a	:     Optional[int]							=  model(A							,						A							,						attention_mask=A							,						token_type_ids=A     )
      a	:     List[Any]							=  model(A							,						A							,						token_type_ids=A     )
      a	:     str							=  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 							lowerCamelCase__ (				self      :   Optional[int]							,						A      :   List[Any]							,						A      :   Tuple							,						A      :   Union[str, Any]							,						A      :   List[Any]							,						A      :   Any							,						A      :   Tuple							,						A      :   int							,						A      :   List[Any]     ):


      '''simple docstring'''




      a	:     Optional[int]							=  LayoutLMForMaskedLM(config=A     )
      model.to(A     )
      model.eval()
      a	:     List[str]							=  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 							lowerCamelCase__ (				self      :   int							,						A      :   Optional[int]							,						A      :   Dict							,						A      :   Union[str, Any]							,						A      :   Dict							,						A      :   List[Any]							,						A      :   Union[str, Any]							,						A      :   Union[str, Any]							,						A      :   Dict     ):


      '''simple docstring'''




      a	:     Dict							=  self.num_labels
      a	:     int							=  LayoutLMForSequenceClassification(A     )
      model.to(A     )
      model.eval()
      a	:     List[str]							=  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 							lowerCamelCase__ (				self      :   Union[str, Any]							,						A      :   int							,						A      :   str							,						A      :   Dict							,						A      :   Tuple							,						A      :   Optional[Any]							,						A      :   Dict							,						A      :   List[str]							,						A      :   str     ):


      '''simple docstring'''




      a	:     str							=  self.num_labels
      a	:     Dict							=  LayoutLMForTokenClassification(config=A     )
      model.to(A     )
      model.eval()
      a	:     Tuple							=  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 							lowerCamelCase__ (				self      :   int							,						A      :   Optional[int]							,						A      :   Optional[Any]							,						A      :   int							,						A      :   str							,						A      :   int							,						A      :   Union[str, Any]							,						A      :   Tuple							,						A      :   Dict     ):


      '''simple docstring'''




      a	:     Optional[Any]							=  LayoutLMForQuestionAnswering(config=A     )
      model.to(A     )
      model.eval()
      a	:     Optional[Any]							=  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 							lowerCamelCase__ (				self      :   Dict     ):


      '''simple docstring'''




      a	:     int							=  self.prepare_config_and_inputs()
      (
          (
          a
      ),	(
          a
      ),	(
          a
      ),	(
          a
      ),	(
          a
      ),	(
          a
      ),	(
          a
      ),	(
          a
      ),	
      )	:     str							=  config_and_inputs
      a	:     List[Any]							=  {
          'input_ids': input_ids,
          'bbox': bbox,
          'token_type_ids': token_type_ids,
          'attention_mask': input_mask,
      }
      return config, inputs_dict






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





    def 							lowerCamelCase__ (				self      :   Dict     ):


      '''simple docstring'''




      a	:     Dict							=  LayoutLMModelTester(self     )
      a	:     Optional[int]							=  ConfigTester(self							,						config_class=A							,						hidden_size=3_7     )





    def 							lowerCamelCase__ (				self      :   Optional[Any]     ):


      '''simple docstring'''




      self.config_tester.run_common_tests()





    def 							lowerCamelCase__ (				self      :   List[str]     ):


      '''simple docstring'''




      a	:     int							=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A     )





    def 							lowerCamelCase__ (				self      :   Optional[Any]     ):


      '''simple docstring'''




      a	:     Tuple							=  self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
        a	:     int							=  type
        self.model_tester.create_and_check_model(*A     )





    def 							lowerCamelCase__ (				self      :   List[Any]     ):


      '''simple docstring'''




      a	:     Optional[Any]							=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*A     )





    def 							lowerCamelCase__ (				self      :   int     ):


      '''simple docstring'''




      a	:     Dict							=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*A     )





    def 							lowerCamelCase__ (				self      :   str     ):


      '''simple docstring'''




      a	:     Dict							=  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*A     )





    def 							lowerCamelCase__ (				self      :   int     ):


      '''simple docstring'''




      a	:     Union[str, Any]							=  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 							lowerCamelCase__ (				self      :   str     ):


      '''simple docstring'''




      pass




def      snake_case    ():







  '''simple docstring'''

  a	:     Any							=  torch.tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]]      ,     device=A_ )  # noqa: E231
  a	:     Any							=  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
  a	:     List[Any]							=  torch.tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]]      ,     device=A_ )  # noqa: E231
  a	:     Optional[int]							=  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)
  a	:     List[Any]							=  torch.tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]]      ,     device=A_ )  # noqa: E231
  # fmt: on

  return input_ids, attention_mask, bbox, token_type_ids, labels






@require_torch
class 		snake_case    (    unittest.TestCase			):





    @slow
    def 							lowerCamelCase__ (				self      :   Union[str, Any]     ):


      '''simple docstring'''




      a	:     Optional[int]							=  LayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'     ).to(A     )

      a,	a,	a,	a,	a	:     List[Any]							=  prepare_layoutlm_batch_inputs()

      # forward pass
      a	:     List[str]							=  model(input_ids=A							,						bbox=A							,						attention_mask=A							,						token_type_ids=A     )

      # test the sequence output on [0, :3, :3]
      a	:     int							=  torch.tensor(
          [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]]							,						device=A							,						)

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

      # test the pooled output on [1, :3]
      a	:     List[str]							=  torch.tensor([-0.65_80, -0.02_14, 0.85_52]							,						device=A     )

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





    @slow
    def 							lowerCamelCase__ (				self      :   Dict     ):


      '''simple docstring'''




      a	:     Tuple							=  LayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'							,						num_labels=2     ).to(
          A     )

      a,	a,	a,	a,	a	:     int							=  prepare_layoutlm_batch_inputs()

      # forward pass
      a	:     Any							=  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
      a	:     Union[str, Any]							=  outputs.loss
      a	:     Dict							=  torch.Size([]     )
      self.assertEqual(loss.shape							,						A     )

      # test the shape of the logits
      a	:     List[Any]							=  outputs.logits
      a	:     Optional[int]							=  torch.Size((2, 2)     )
      self.assertEqual(logits.shape							,						A     )





    @slow
    def 							lowerCamelCase__ (				self      :   List[Any]     ):


      '''simple docstring'''




      a	:     List[str]							=  LayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'							,						num_labels=1_3     ).to(
          A     )

      a,	a,	a,	a,	a	:     Any							=  prepare_layoutlm_batch_inputs()

      # forward pass
      a	:     Optional[Any]							=  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
      a	:     int							=  outputs.logits
      a	:     Tuple							=  torch.Size((2, 2_5, 1_3)     )
      self.assertEqual(logits.shape							,						A     )





    @slow
    def 							lowerCamelCase__ (				self      :   Dict     ):


      '''simple docstring'''




      a	:     Optional[int]							=  LayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'     ).to(A     )

      a,	a,	a,	a,	a	:     Tuple							=  prepare_layoutlm_batch_inputs()

      # forward pass
      a	:     Tuple							=  model(input_ids=A							,						bbox=A							,						attention_mask=A							,						token_type_ids=A     )

      # test the shape of the logits
      a	:     Any							=  torch.Size((2, 2_5)     )
      self.assertEqual(outputs.start_logits.shape							,						A     )
      self.assertEqual(outputs.end_logits.shape							,						A     )












"""simple docstring"""


from __future__ import annotations




def      snake_case    (A_ :int ):







  '''simple docstring'''

  assert (
      isinstance(A_      ,     A_ ) and mask > 0
  ), f'''mask needs to be positive integer, your input {mask}'''
  a	:     Any							=  []
  a	:     Union[str, Any]							=  mask

  while submask:
    all_submasks.append(A_ )
    a	:     Any							=  (submask - 1) & mask

  return all_submasks


if __name__ == "__main__":
   import doctest

   doctest.testmod()




