


from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers.models.layoutlm.modeling_tf_layoutlm import (
        TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFLayoutLMForMaskedLM,
        TFLayoutLMForQuestionAnswering,
        TFLayoutLMForSequenceClassification,
        TFLayoutLMForTokenClassification,
        TFLayoutLMModel,
    )



class A__     :



  """simple docstring"""



  def __init__( self			:  List[Any]				,				lowerCamelCase__			:  Tuple				,				lowerCamelCase__			:  Tuple=13				,				lowerCamelCase__			:  List[Any]=7				,				lowerCamelCase__			:  Any=True				,				lowerCamelCase__			:  Any=True				,				lowerCamelCase__			:  Dict=True				,				lowerCamelCase__			:  Any=True				,				lowerCamelCase__			:  Optional[Any]=99				,				lowerCamelCase__			:  Tuple=32				,				lowerCamelCase__			:  Union[str, Any]=2				,				lowerCamelCase__			:  Any=4				,				lowerCamelCase__			:  int=37				,				lowerCamelCase__			:  Tuple="gelu"				,				lowerCamelCase__			:  int=0.1				,				lowerCamelCase__			:  str=0.1				,				lowerCamelCase__			:  Optional[int]=512				,				lowerCamelCase__			:  str=16				,				lowerCamelCase__			:  List[Any]=2				,				lowerCamelCase__			:  int=0.02				,				lowerCamelCase__			:  List[Any]=3				,				lowerCamelCase__			:  List[Any]=4				,				lowerCamelCase__			:  Optional[Any]=None				,				lowerCamelCase__			:  int=1_000				,				):
        a__	:  Union[str, Any]     =   parent
        a__	:  Optional[Any]     =   batch_size
        a__	:  Optional[int]     =   seq_length
        a__	:  Any     =   is_training
        a__	:  Tuple     =   use_input_mask
        a__	:  str     =   use_token_type_ids
        a__	:  int     =   use_labels
        a__	:  int     =   vocab_size
        a__	:  int     =   hidden_size
        a__	:  List[str]     =   num_hidden_layers
        a__	:  Tuple     =   num_attention_heads
        a__	:  Any     =   intermediate_size
        a__	:  Tuple     =   hidden_act
        a__	:  List[Any]     =   hidden_dropout_prob
        a__	:  List[Any]     =   attention_probs_dropout_prob
        a__	:  Dict     =   max_position_embeddings
        a__	:  int     =   type_vocab_size
        a__	:  str     =   type_sequence_label_size
        a__	:  List[str]     =   initializer_range
        a__	:  List[str]     =   num_labels
        a__	:  Any     =   num_choices
        a__	:  Union[str, Any]     =   scope
        a__	:  Dict     =   range_bbox

  def    _UpperCamelCase( self			:  Optional[Any]       ):
        a__	:  int     =   ids_tensor([self.batch_size, self.seq_length]				,				self.vocab_size       )

        # convert bbox to numpy since TF does not support item assignment
        a__	:  Any     =   ids_tensor([self.batch_size, self.seq_length, 4]				,				self.range_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]:
                          a__	:  int     =   bbox[i, j, 3]
                          a__	:  str     =   bbox[i, j, 1]
                          a__	:  int     =   t
                    if bbox[i, j, 2] < bbox[i, j, 0]:
                          a__	:  Union[str, Any]     =   bbox[i, j, 2]
                          a__	:  int     =   bbox[i, j, 0]
                          a__	:  Dict     =   t
        a__	:  List[str]     =   tf.convert_to_tensor(lowerCamelCase__       )

        a__	:  Union[str, Any]     =   None
        if self.use_input_mask:
              a__	:  List[Any]     =   random_attention_mask([self.batch_size, self.seq_length]       )

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

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

        a__	:  Tuple     =   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				,				)

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

  def    _UpperCamelCase( self			:  List[Any]				,				lowerCamelCase__			:  Optional[Any]				,				lowerCamelCase__			:  Union[str, Any]				,				lowerCamelCase__			:  Optional[Any]				,				lowerCamelCase__			:  Dict				,				lowerCamelCase__			:  Dict				,				lowerCamelCase__			:  Optional[Any]				,				lowerCamelCase__			:  int				,				lowerCamelCase__			:  List[Any]       ):
        a__	:  Any     =   TFLayoutLMModel(config=lowerCamelCase__       )

        a__	:  Any     =   model(lowerCamelCase__				,				lowerCamelCase__				,				attention_mask=lowerCamelCase__				,				token_type_ids=lowerCamelCase__       )
        a__	:  List[Any]     =   model(lowerCamelCase__				,				lowerCamelCase__				,				token_type_ids=lowerCamelCase__       )
        a__	:  Tuple     =   model(lowerCamelCase__				,				lowerCamelCase__       )
        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    _UpperCamelCase( self			:  int				,				lowerCamelCase__			:  str				,				lowerCamelCase__			:  Dict				,				lowerCamelCase__			:  List[str]				,				lowerCamelCase__			:  Optional[Any]				,				lowerCamelCase__			:  List[str]				,				lowerCamelCase__			:  int				,				lowerCamelCase__			:  int				,				lowerCamelCase__			:  str       ):
        a__	:  int     =   TFLayoutLMForMaskedLM(config=lowerCamelCase__       )

        a__	:  Union[str, Any]     =   model(lowerCamelCase__				,				lowerCamelCase__				,				attention_mask=lowerCamelCase__				,				token_type_ids=lowerCamelCase__				,				labels=lowerCamelCase__       )
        self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.vocab_size)       )

  def    _UpperCamelCase( self			:  Tuple				,				lowerCamelCase__			:  Union[str, Any]				,				lowerCamelCase__			:  Any				,				lowerCamelCase__			:  Union[str, Any]				,				lowerCamelCase__			:  int				,				lowerCamelCase__			:  Dict				,				lowerCamelCase__			:  List[Any]				,				lowerCamelCase__			:  Dict				,				lowerCamelCase__			:  Tuple       ):
        a__	:  Any     =   self.num_labels
        a__	:  Optional[Any]     =   TFLayoutLMForSequenceClassification(config=lowerCamelCase__       )

        a__	:  int     =   model(lowerCamelCase__				,				lowerCamelCase__				,				attention_mask=lowerCamelCase__				,				token_type_ids=lowerCamelCase__       )
        self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_labels)       )

  def    _UpperCamelCase( self			:  Dict				,				lowerCamelCase__			:  Any				,				lowerCamelCase__			:  Optional[int]				,				lowerCamelCase__			:  Optional[Any]				,				lowerCamelCase__			:  int				,				lowerCamelCase__			:  Any				,				lowerCamelCase__			:  Any				,				lowerCamelCase__			:  str				,				lowerCamelCase__			:  Dict       ):
        a__	:  Any     =   self.num_labels
        a__	:  Any     =   TFLayoutLMForTokenClassification(config=lowerCamelCase__       )

        a__	:  int     =   model(lowerCamelCase__				,				lowerCamelCase__				,				attention_mask=lowerCamelCase__				,				token_type_ids=lowerCamelCase__				,				labels=lowerCamelCase__       )
        self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.num_labels)       )

  def    _UpperCamelCase( self			:  Dict				,				lowerCamelCase__			:  Dict				,				lowerCamelCase__			:  Any				,				lowerCamelCase__			:  List[Any]				,				lowerCamelCase__			:  str				,				lowerCamelCase__			:  Optional[int]				,				lowerCamelCase__			:  List[Any]				,				lowerCamelCase__			:  Optional[Any]				,				lowerCamelCase__			:  List[str]       ):
        a__	:  Optional[int]     =   TFLayoutLMForQuestionAnswering(config=lowerCamelCase__       )

        a__	:  List[str]     =   model(lowerCamelCase__				,				lowerCamelCase__				,				attention_mask=lowerCamelCase__				,				token_type_ids=lowerCamelCase__       )
        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			:  Dict       ):
        a__	:  Union[str, Any]     =   self.prepare_config_and_inputs()
        (
            (
            a__
        ),	(
            a__
        ),	(
            a__
        ),	(
            a__
        ),	(
            a__
        ),	(
            a__
        ),	(
            a__
        ),	(
            a__
        ),	
        )	:  List[Any]     =   config_and_inputs
        a__	:  Optional[int]     =   {
            "input_ids": input_ids,
            "bbox": bbox,
            "token_type_ids": token_type_ids,
            "attention_mask": input_mask,
        }
        return config, inputs_dict




@require_tf
class A__     ( A__				,		A__				,		unittest.TestCase  ):



  """simple docstring"""



  _lowercase									=		(
      (
          TFLayoutLMModel,
          TFLayoutLMForMaskedLM,
          TFLayoutLMForTokenClassification,
          TFLayoutLMForSequenceClassification,
          TFLayoutLMForQuestionAnswering,
      )
      if is_tf_available()
      else ()
  )
  _lowercase									=		(
      {
          'feature-extraction': TFLayoutLMModel,
          'fill-mask': TFLayoutLMForMaskedLM,
          'text-classification': TFLayoutLMForSequenceClassification,
          'token-classification': TFLayoutLMForTokenClassification,
          'zero-shot': TFLayoutLMForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  _lowercase									=		False
  _lowercase									=		True
  _lowercase									=		1_0

  def    _UpperCamelCase( self			:  List[str]       ):
        a__	:  Optional[int]     =   TFLayoutLMModelTester(self       )
        a__	:  Union[str, Any]     =   ConfigTester(self				,				config_class=lowerCamelCase__				,				hidden_size=37       )

  def    _UpperCamelCase( self			:  List[str]       ):
        self.config_tester.run_common_tests()

  def    _UpperCamelCase( self			:  int       ):
        a__	:  Dict     =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCamelCase__       )

  def    _UpperCamelCase( self			:  Optional[Any]       ):
        a__	:  Tuple     =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase__       )

  def    _UpperCamelCase( self			:  Any       ):
        a__	:  Optional[Any]     =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase__       )

  def    _UpperCamelCase( self			:  str       ):
        a__	:  int     =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*lowerCamelCase__       )

  def    _UpperCamelCase( self			:  int       ):
        a__	:  int     =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*lowerCamelCase__       )

  @slow
  def    _UpperCamelCase( self			:  Tuple       ):
        for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              a__	:  str     =   TFLayoutLMModel.from_pretrained(lowerCamelCase__       )
              self.assertIsNotNone(lowerCamelCase__       )

  @unittest.skip("Onnx compliancy broke with TF 2.10"       )
  def    _UpperCamelCase( self			:  Optional[int]       ):
        pass




def UpperCamelCase_				(				)	->   List[Any]:
      # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
      # fmt: off
      a__	:  Optional[Any]     =   tf.convert_to_tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]]      )  # noqa: E231
      a__	:  Optional[int]     =   tf.convert_to_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],]      )  # noqa: E231
      a__	:  Tuple     =   tf.convert_to_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],[1_000,1_000,1_000,1_000]],[[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],[1_000,1_000,1_000,1_000]]]      )  # noqa: E231
      a__	:  Any     =   tf.convert_to_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]]      )  # noqa: E231
      # these are sequence labels (i.e. at the token level)
      a__	:  List[str]     =   tf.convert_to_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]]      )  # noqa: E231
      # fmt: on

      return input_ids, attention_mask, bbox, token_type_ids, labels



@require_tf
class A__     ( unittest.TestCase  ):



  """simple docstring"""



  @slow
  def    _UpperCamelCase( self			:  int       ):
        a__	:  Union[str, Any]     =   TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"       )

        a__,	a__,	a__,	a__,	a__	:  Tuple     =   prepare_layoutlm_batch_inputs()

        # forward pass
        a__	:  Optional[int]     =   model(input_ids=lowerCamelCase__				,				bbox=lowerCamelCase__				,				attention_mask=lowerCamelCase__				,				token_type_ids=lowerCamelCase__       )

        # test the sequence output on [0, :3, :3]
        a__	:  Dict     =   tf.convert_to_tensor(
            [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]				,				)

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

        # test the pooled output on [1, :3]
        a__	:  Tuple     =   tf.convert_to_tensor([-0.6580, -0.0214, 0.8552]       )

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

  @slow
  def    _UpperCamelCase( self			:  Optional[int]       ):
        # initialize model with randomly initialized sequence classification head
        a__	:  Tuple     =   TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"				,				num_labels=2       )

        a__,	a__,	a__,	a__,	a__	:  str     =   prepare_layoutlm_batch_inputs()

        # forward pass
        a__	:  Optional[Any]     =   model(
            input_ids=lowerCamelCase__				,				bbox=lowerCamelCase__				,				attention_mask=lowerCamelCase__				,				token_type_ids=lowerCamelCase__				,				labels=tf.convert_to_tensor([1, 1]       )				,				)

        # test whether we get a loss as a scalar
        a__	:  Union[str, Any]     =   outputs.loss
        a__	:  Tuple     =   (2,)
        self.assertEqual(loss.shape				,				lowerCamelCase__       )

        # test the shape of the logits
        a__	:  Dict     =   outputs.logits
        a__	:  Any     =   (2, 2)
        self.assertEqual(logits.shape				,				lowerCamelCase__       )

  @slow
  def    _UpperCamelCase( self			:  List[str]       ):
        # initialize model with randomly initialized token classification head
        a__	:  str     =   TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"				,				num_labels=13       )

        a__,	a__,	a__,	a__,	a__	:  Optional[Any]     =   prepare_layoutlm_batch_inputs()

        # forward pass
        a__	:  Optional[Any]     =   model(
            input_ids=lowerCamelCase__				,				bbox=lowerCamelCase__				,				attention_mask=lowerCamelCase__				,				token_type_ids=lowerCamelCase__				,				labels=lowerCamelCase__       )

        # test the shape of the logits
        a__	:  Any     =   outputs.logits
        a__	:  List[Any]     =   tf.convert_to_tensor((2, 25, 13)       )
        self.assertEqual(logits.shape				,				lowerCamelCase__       )

  @slow
  def    _UpperCamelCase( self			:  int       ):
        # initialize model with randomly initialized token classification head
        a__	:  Tuple     =   TFLayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"       )

        a__,	a__,	a__,	a__,	a__	:  Union[str, Any]     =   prepare_layoutlm_batch_inputs()

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

        # test the shape of the logits
        a__	:  Dict     =   tf.convert_to_tensor((2, 25)       )
        self.assertEqual(outputs.start_logits.shape				,				lowerCamelCase__       )
        self.assertEqual(outputs.end_logits.shape				,				lowerCamelCase__       )



import argparse

import torch

from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
from transformers.utils import logging


logging.set_verbosity_info()


def      UpperCamelCase   (       __lowerCamelCase	:					List[str]							,   __lowerCamelCase	:					Union[str, Any]							,   __lowerCamelCase	:					Union[str, Any]       ):
       # Initialise PyTorch model
       snake_case			:  Optional[int]     							= BertConfig.from_json_file(__lowerCamelCase       )
       print(f"""Building PyTorch model from configuration: {config}"""       )
       snake_case			:  Any     							= BertForPreTraining(__lowerCamelCase       )

       # Load weights from tf checkpoint
       load_tf_weights_in_bert(__lowerCamelCase							,   __lowerCamelCase							,   __lowerCamelCase       )

       # Save pytorch-model
       print(f"""Save PyTorch model to {pytorch_dump_path}"""       )
       torch.save(model.state_dict()							,   __lowerCamelCase       )


if __name__ == "__main__":
   __lowerCamelCase				=			argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
   )
   parser.add_argument(
       """--bert_config_file""",
       default=None,
       type=str,
       required=True,
       help=(
           """The config json file corresponding to the pre-trained BERT model. \n"""
           """This specifies the model architecture."""
       ),
   )
   parser.add_argument(
       """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
   )
   __lowerCamelCase				=			parser.parse_args()
   convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)





