

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




  def __init__(							self				,  lowerCAmelCase				,  lowerCAmelCase=13				,  lowerCAmelCase=7				,  lowerCAmelCase=True				,  lowerCAmelCase=True				,  lowerCAmelCase=True				,  lowerCAmelCase=True				,  lowerCAmelCase=99				,  lowerCAmelCase=32				,  lowerCAmelCase=2				,  lowerCAmelCase=4				,  lowerCAmelCase=37				,  lowerCAmelCase="gelu"				,  lowerCAmelCase=0.1				,  lowerCAmelCase=0.1				,  lowerCAmelCase=512				,  lowerCAmelCase=16				,  lowerCAmelCase=2				,  lowerCAmelCase=0.02				,  lowerCAmelCase=3				,  lowerCAmelCase=4				,  lowerCAmelCase=None				,  lowerCAmelCase=1_000				,  )    ->					Any:
        '''simple docstring'''






        _lowercase      			=parent
        _lowercase      			=batch_size
        _lowercase      			=seq_length
        _lowercase      			=is_training
        _lowercase      			=use_input_mask
        _lowercase      			=use_token_type_ids
        _lowercase      			=use_labels
        _lowercase      			=vocab_size
        _lowercase      			=hidden_size
        _lowercase      			=num_hidden_layers
        _lowercase      			=num_attention_heads
        _lowercase      			=intermediate_size
        _lowercase      			=hidden_act
        _lowercase      			=hidden_dropout_prob
        _lowercase      			=attention_probs_dropout_prob
        _lowercase      			=max_position_embeddings
        _lowercase      			=type_vocab_size
        _lowercase      			=type_sequence_label_size
        _lowercase      			=initializer_range
        _lowercase      			=num_labels
        _lowercase      			=num_choices
        _lowercase      			=scope
        _lowercase      			=range_bbox




  def     A__	(							self   )    ->					Optional[Any]:
        '''simple docstring'''






        _lowercase      			=ids_tensor([self.batch_size, self.seq_length]				,  self.vocab_size   )

        # convert bbox to numpy since TF does not support item assignment
        _lowercase      			=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]:
                          _lowercase      			=bbox[i, j, 3]
                          _lowercase      			=bbox[i, j, 1]
                          _lowercase      			=t
                    if bbox[i, j, 2] < bbox[i, j, 0]:
                          _lowercase      			=bbox[i, j, 2]
                          _lowercase      			=bbox[i, j, 0]
                          _lowercase      			=t
        _lowercase      			=tf.convert_to_tensor(lowerCAmelCase   )

        _lowercase      			=None
        if self.use_input_mask:
              _lowercase      			=random_attention_mask([self.batch_size, self.seq_length]   )

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

        _lowercase      			=None
        _lowercase      			=None
        _lowercase      			=None
        if self.use_labels:
              _lowercase      			=ids_tensor([self.batch_size]				,  self.type_sequence_label_size   )
              _lowercase      			=ids_tensor([self.batch_size, self.seq_length]				,  self.num_labels   )
              _lowercase      			=ids_tensor([self.batch_size]				,  self.num_choices   )

        _lowercase      			=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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					List[Any]:
        '''simple docstring'''






        _lowercase      			=TFLayoutLMModel(config=lowerCAmelCase   )

        _lowercase      			=model(lowerCAmelCase				,  lowerCAmelCase				,  attention_mask=lowerCAmelCase				,  token_type_ids=lowerCAmelCase   )
        _lowercase      			=model(lowerCAmelCase				,  lowerCAmelCase				,  token_type_ids=lowerCAmelCase   )
        _lowercase      			=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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					List[Any]:
        '''simple docstring'''






        _lowercase      			=TFLayoutLMForMaskedLM(config=lowerCAmelCase   )

        _lowercase      			=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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					List[str]:
        '''simple docstring'''






        _lowercase      			=self.num_labels
        _lowercase      			=TFLayoutLMForSequenceClassification(config=lowerCAmelCase   )

        _lowercase      			=model(lowerCAmelCase				,  lowerCAmelCase				,  attention_mask=lowerCAmelCase				,  token_type_ids=lowerCAmelCase   )
        self.parent.assertEqual(result.logits.shape				,  (self.batch_size, self.num_labels)   )




  def     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					List[Any]:
        '''simple docstring'''






        _lowercase      			=self.num_labels
        _lowercase      			=TFLayoutLMForTokenClassification(config=lowerCAmelCase   )

        _lowercase      			=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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=TFLayoutLMForQuestionAnswering(config=lowerCAmelCase   )

        _lowercase      			=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     A__	(							self   )    ->					List[Any]:
        '''simple docstring'''






        _lowercase      			=self.prepare_config_and_inputs()
        (
            (
            _lowercase
        )			,			(
            _lowercase
        )			,			(
            _lowercase
        )			,			(
            _lowercase
        )			,			(
            _lowercase
        )			,			(
            _lowercase
        )			,			(
            _lowercase
        )			,			(
            _lowercase
        )			,			
        )      			=config_and_inputs
        _lowercase      			={
            'input_ids': input_ids,
            'bbox': bbox,
            'token_type_ids': token_type_ids,
            'attention_mask': input_mask,
        }
        return config, inputs_dict





@require_tf
class 					__lowerCAmelCase	(   SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     unittest.TestCase				):
  _a		     =    (
      (
          TFLayoutLMModel,
          TFLayoutLMForMaskedLM,
          TFLayoutLMForTokenClassification,
          TFLayoutLMForSequenceClassification,
          TFLayoutLMForQuestionAnswering,
      )
      if is_tf_available()
      else ()
  )
  _a		     =    (
      {
          """feature-extraction""": TFLayoutLMModel,
          """fill-mask""": TFLayoutLMForMaskedLM,
          """text-classification""": TFLayoutLMForSequenceClassification,
          """token-classification""": TFLayoutLMForTokenClassification,
          """zero-shot""": TFLayoutLMForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  _a		     =    False
  _a		     =    True
  _a		     =    10




  def     A__	(							self   )    ->					Optional[int]:
        '''simple docstring'''






        _lowercase      			=TFLayoutLMModelTester(self   )
        _lowercase      			=ConfigTester(self				,  config_class=lowerCAmelCase				,  hidden_size=37   )




  def     A__	(							self   )    ->					List[Any]:
        '''simple docstring'''






        self.config_tester.run_common_tests()




  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCAmelCase   )




  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase   )




  def     A__	(							self   )    ->					Union[str, Any]:
        '''simple docstring'''






        _lowercase      			=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase   )




  def     A__	(							self   )    ->					int:
        '''simple docstring'''






        _lowercase      			=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase   )




  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase   )




  @slow
  def     A__	(							self   )    ->					Optional[Any]:
        '''simple docstring'''






        for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              _lowercase      			=TFLayoutLMModel.from_pretrained(lowerCAmelCase   )
              self.assertIsNotNone(lowerCAmelCase   )




  @unittest.skip('Onnx compliancy broke with TF 2.10'   )
  def     A__	(							self   )    ->					str:
        '''simple docstring'''






        pass
def 	a (     )       -> str:





      """simple docstring"""



      _lowercase      			=tf.convert_to_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]]	)  # noqa: E231
      _lowercase      			=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
      _lowercase      			=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],[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]]]	)  # noqa: E231
      _lowercase      			=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)
      _lowercase      			=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 					__lowerCAmelCase	(   unittest.TestCase				):




  @slow
  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'   )

        _lowercase			,			_lowercase			,			_lowercase			,			_lowercase			,			_lowercase      			=prepare_layoutlm_batch_inputs()

        # forward pass
        _lowercase      			=model(input_ids=lowerCAmelCase				,  bbox=lowerCAmelCase				,  attention_mask=lowerCAmelCase				,  token_type_ids=lowerCAmelCase   )

        # test the sequence output on [0, :3, :3]
        _lowercase      			=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]
        _lowercase      			=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     A__	(							self   )    ->					Union[str, Any]:
        '''simple docstring'''






        _lowercase      			=TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'				,  num_labels=2   )

        _lowercase			,			_lowercase			,			_lowercase			,			_lowercase			,			_lowercase      			=prepare_layoutlm_batch_inputs()

        # forward pass
        _lowercase      			=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
        _lowercase      			=outputs.loss
        _lowercase      			=(2,)
        self.assertEqual(loss.shape				,  lowerCAmelCase   )

        # test the shape of the logits
        _lowercase      			=outputs.logits
        _lowercase      			=(2, 2)
        self.assertEqual(logits.shape				,  lowerCAmelCase   )




  @slow
  def     A__	(							self   )    ->					Union[str, Any]:
        '''simple docstring'''






        _lowercase      			=TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'				,  num_labels=13   )

        _lowercase			,			_lowercase			,			_lowercase			,			_lowercase			,			_lowercase      			=prepare_layoutlm_batch_inputs()

        # forward pass
        _lowercase      			=model(
            input_ids=lowerCAmelCase				,  bbox=lowerCAmelCase				,  attention_mask=lowerCAmelCase				,  token_type_ids=lowerCAmelCase				,  labels=lowerCAmelCase   )

        # test the shape of the logits
        _lowercase      			=outputs.logits
        _lowercase      			=tf.convert_to_tensor((2, 25, 13)   )
        self.assertEqual(logits.shape				,  lowerCAmelCase   )




  @slow
  def     A__	(							self   )    ->					int:
        '''simple docstring'''






        _lowercase      			=TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'   )

        _lowercase			,			_lowercase			,			_lowercase			,			_lowercase			,			_lowercase      			=prepare_layoutlm_batch_inputs()

        # forward pass
        _lowercase      			=model(input_ids=lowerCAmelCase				,  bbox=lowerCAmelCase				,  attention_mask=lowerCAmelCase				,  token_type_ids=lowerCAmelCase   )

        # test the shape of the logits
        _lowercase      			=tf.convert_to_tensor((2, 25)   )
        self.assertEqual(outputs.start_logits.shape				,  lowerCAmelCase   )
        self.assertEqual(outputs.end_logits.shape				,  lowerCAmelCase   )





from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowercase_   							=  logging.get_logger(__name__)

lowercase_   							=  {
    'distilbert-base-uncased': 'https://huggingface.co/distilbert-base-uncased/resolve/main/config.json',
    'distilbert-base-uncased-distilled-squad': (
        'https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/config.json'
    ),
    'distilbert-base-cased': 'https://huggingface.co/distilbert-base-cased/resolve/main/config.json',
    'distilbert-base-cased-distilled-squad': (
        'https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/config.json'
    ),
    'distilbert-base-german-cased': 'https://huggingface.co/distilbert-base-german-cased/resolve/main/config.json',
    'distilbert-base-multilingual-cased': (
        'https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/config.json'
    ),
    'distilbert-base-uncased-finetuned-sst-2-english': (
        'https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english/resolve/main/config.json'
    ),
}





class 					__lowerCAmelCase	(   SCREAMING_SNAKE_CASE				):
  _a		     =    """distilbert"""
  _a		     =    {
      """hidden_size""": """dim""",
      """num_attention_heads""": """n_heads""",
      """num_hidden_layers""": """n_layers""",
  }




  def __init__(							self				,  lowerCAmelCase=30_522				,  lowerCAmelCase=512				,  lowerCAmelCase=False				,  lowerCAmelCase=6				,  lowerCAmelCase=12				,  lowerCAmelCase=768				,  lowerCAmelCase=4 * 768				,  lowerCAmelCase=0.1				,  lowerCAmelCase=0.1				,  lowerCAmelCase="gelu"				,  lowerCAmelCase=0.02				,  lowerCAmelCase=0.1				,  lowerCAmelCase=0.2				,  lowerCAmelCase=0				,  **lowerCAmelCase				,  )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=vocab_size
        _lowercase      			=max_position_embeddings
        _lowercase      			=sinusoidal_pos_embds
        _lowercase      			=n_layers
        _lowercase      			=n_heads
        _lowercase      			=dim
        _lowercase      			=hidden_dim
        _lowercase      			=dropout
        _lowercase      			=attention_dropout
        _lowercase      			=activation
        _lowercase      			=initializer_range
        _lowercase      			=qa_dropout
        _lowercase      			=seq_classif_dropout
        super().__init__(**lowerCAmelCase				,  pad_token_id=lowerCAmelCase   )





class 					__lowerCAmelCase	(   SCREAMING_SNAKE_CASE				):




  @property
  def     A__	(							self   )    ->					Mapping[str, Mapping[int, str]]:
        '''simple docstring'''






        if self.task == "multiple-choice":
              _lowercase      			={0: 'batch', 1: 'choice', 2: 'sequence'}
        else:
              _lowercase      			={0: 'batch', 1: 'sequence'}
        return OrderedDict(
            [
                ('input_ids', dynamic_axis),
                ('attention_mask', dynamic_axis),
            ]   )


