




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






				'''simple docstring'''





				def __init__( self	,				_a	,				_a=13	,				_a=7	,				_a=True	,				_a=True	,				_a=True	,				_a=True	,				_a=99	,				_a=32	,				_a=2	,				_a=4	,				_a=37	,				_a="gelu"	,				_a=0.1	,				_a=0.1	,				_a=512	,				_a=16	,				_a=2	,				_a=0.02	,				_a=3	,				_a=4	,				_a=None	,				_a=1_000	,				):





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





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      ids_tensor([self.batch_size, self.seq_length]	,				self.vocab_size				)

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

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

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

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

							lowerCamelCase       =      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      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a				):





							"""simple docstring"""
							lowerCamelCase       =      TFLayoutLMModel(config=_a				)

							lowerCamelCase       =      model(_a	,				_a	,				attention_mask=_a	,				token_type_ids=_a				)
							lowerCamelCase       =      model(_a	,				_a	,				token_type_ids=_a				)
							lowerCamelCase       =      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	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a				):





							"""simple docstring"""
							lowerCamelCase       =      TFLayoutLMForMaskedLM(config=_a				)

							lowerCamelCase       =      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	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a				):





							"""simple docstring"""
							lowerCamelCase       =      self.num_labels
							lowerCamelCase       =      TFLayoutLMForSequenceClassification(config=_a				)

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





				def      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a				):





							"""simple docstring"""
							lowerCamelCase       =      self.num_labels
							lowerCamelCase       =      TFLayoutLMForTokenClassification(config=_a				)

							lowerCamelCase       =      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	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a				):





							"""simple docstring"""
							lowerCamelCase       =      TFLayoutLMForQuestionAnswering(config=_a				)

							lowerCamelCase       =      model(_a	,				_a	,				attention_mask=_a	,				token_type_ids=_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				):





							"""simple docstring"""
							lowerCamelCase       =      self.prepare_config_and_inputs()
							(
							    (
							    lowerCamelCase     
							)   ,     (
							    lowerCamelCase     
							)   ,     (
							    lowerCamelCase     
							)   ,     (
							    lowerCamelCase     
							)   ,     (
							    lowerCamelCase     
							)   ,     (
							    lowerCamelCase     
							)   ,     (
							    lowerCamelCase     
							)   ,     (
							    lowerCamelCase     
							)   ,          
							)       =      config_and_inputs
							lowerCamelCase       =      {
							    """input_ids""": input_ids,
							    """bbox""": bbox,
							    """token_type_ids""": token_type_ids,
							    """attention_mask""": input_mask,
							}
							return config, inputs_dict






@require_tf
class 					__magic_name__							( UpperCAmelCase__		,      UpperCAmelCase__		,      unittest.TestCase       ):






				'''simple docstring'''
				__UpperCamelCase    						=		(
				    (
				        TFLayoutLMModel,
				        TFLayoutLMForMaskedLM,
				        TFLayoutLMForTokenClassification,
				        TFLayoutLMForSequenceClassification,
				        TFLayoutLMForQuestionAnswering,
				    )
				    if is_tf_available()
				    else ()
				)
				__UpperCamelCase    						=		(
				    {
				        "feature-extraction": TFLayoutLMModel,
				        "fill-mask": TFLayoutLMForMaskedLM,
				        "text-classification": TFLayoutLMForSequenceClassification,
				        "token-classification": TFLayoutLMForTokenClassification,
				        "zero-shot": TFLayoutLMForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		True
				__UpperCamelCase    						=		10





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFLayoutLMModelTester(self				)
							lowerCamelCase       =      ConfigTester(self	,				config_class=_a	,				hidden_size=37				)





				def      _lowerCAmelCase       ( self				):





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





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*_a				)





				@slow
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCamelCase       =      TFLayoutLMModel.from_pretrained(_a				)
										self.assertIsNotNone(_a				)





				@unittest.skip("""Onnx compliancy broke with TF 2.10"""				)
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							pass




def 					a__				(       )		->      Tuple:
			# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
			# fmt: off
			lowerCamelCase       =      tf.convert_to_tensor([[1_01,10_19,10_14,10_16,10_37,1_28_49,47_47,10_04,1_42_46,22_78,54_39,45_24,50_02,29_30,21_93,29_30,43_41,32_08,10_05,10_55,21_71,28_48,1_13_00,35_31,1_02],[1_01,40_70,40_34,70_20,10_24,30_58,10_15,10_13,28_61,10_13,60_70,1_92_74,27_72,62_05,2_78_14,1_61_47,1_61_47,43_43,20_47,1_02_83,1_09_69,1_43_89,10_12,23_38,1_02]]       )  # noqa: E231
			lowerCamelCase       =      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
			lowerCamelCase       =      tf.convert_to_tensor([[[0,0,0,0],[4_23,2_37,4_40,2_51],[4_27,2_72,4_41,2_87],[4_19,1_15,4_37,1_29],[9_61,8_85,9_92,9_12],[2_56,38,3_30,58],[2_56,38,3_30,58],[3_36,42,3_53,57],[3_60,39,4_01,56],[3_60,39,4_01,56],[4_11,39,4_71,59],[4_79,41,5_28,59],[5_33,39,6_30,60],[67,1_13,1_34,1_31],[1_41,1_15,2_09,1_32],[68,1_49,1_33,1_66],[1_41,1_49,1_87,1_64],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[2_95,1_48,3_49,1_65],[4_41,1_49,4_92,1_66],[4_97,1_49,5_46,1_64],[64,2_01,1_25,2_18],[10_00,10_00,10_00,10_00]],[[0,0,0,0],[6_62,1_50,7_54,1_66],[6_65,1_99,7_42,2_11],[5_19,2_13,5_54,2_28],[5_19,2_13,5_54,2_28],[1_34,4_33,1_87,4_54],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[3_14,4_69,3_76,4_82],[5_04,6_84,5_82,7_06],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[6_10,7_49,6_52,7_65],[1_30,6_59,1_68,6_72],[1_76,6_57,2_37,6_72],[2_38,6_57,3_12,6_72],[4_43,6_53,6_28,6_72],[4_43,6_53,6_28,6_72],[7_16,3_01,8_25,3_17],[10_00,10_00,10_00,10_00]]]       )  # noqa: E231
			lowerCamelCase       =      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)
			lowerCamelCase       =      tf.convert_to_tensor([[-1_00,10,10,10,9,1,-1_00,7,7,-1_00,7,7,4,2,5,2,8,8,-1_00,-1_00,5,0,3,2,-1_00],[-1_00,12,12,12,-1_00,12,10,-1_00,-1_00,-1_00,-1_00,10,12,9,-1_00,-1_00,-1_00,10,10,10,9,12,-1_00,10,-1_00]]       )  # noqa: E231
			# fmt: on

			return input_ids, attention_mask, bbox, token_type_ids, labels






@require_tf
class 					__magic_name__							( unittest.TestCase       ):






				'''simple docstring'''





				@slow
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFLayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""				)

							lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase       =      prepare_layoutlm_batch_inputs()

							# forward pass
							lowerCamelCase       =      model(input_ids=_a	,				bbox=_a	,				attention_mask=_a	,				token_type_ids=_a				)

							# test the sequence output on [0, :3, :3]
							lowerCamelCase       =      tf.convert_to_tensor(
							    [[0.1_785, -0.1_947, -0.0_425], [-0.3_254, -0.2_807, 0.2_553], [-0.5_391, -0.3_322, 0.3_364]]	,				)

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

							# test the pooled output on [1, :3]
							lowerCamelCase       =      tf.convert_to_tensor([-0.6_580, -0.0_214, 0.8_552]				)

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





				@slow
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFLayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""	,				num_labels=2				)

							lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase       =      prepare_layoutlm_batch_inputs()

							# forward pass
							lowerCamelCase       =      model(
							    input_ids=_a	,				bbox=_a	,				attention_mask=_a	,				token_type_ids=_a	,				labels=tf.convert_to_tensor([1, 1]				)	,				)

							# test whether we get a loss as a scalar
							lowerCamelCase       =      outputs.loss
							lowerCamelCase       =      (2,)
							self.assertEqual(loss.shape	,				_a				)

							# test the shape of the logits
							lowerCamelCase       =      outputs.logits
							lowerCamelCase       =      (2, 2)
							self.assertEqual(logits.shape	,				_a				)





				@slow
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFLayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""	,				num_labels=13				)

							lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase       =      prepare_layoutlm_batch_inputs()

							# forward pass
							lowerCamelCase       =      model(
							    input_ids=_a	,				bbox=_a	,				attention_mask=_a	,				token_type_ids=_a	,				labels=_a				)

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





				@slow
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFLayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""				)

							lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase       =      prepare_layoutlm_batch_inputs()

							# forward pass
							lowerCamelCase       =      model(input_ids=_a	,				bbox=_a	,				attention_mask=_a	,				token_type_ids=_a				)

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









"""simple docstring"""




from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase							:    Dict  							=							logging.get_logger(__name__)

lowerCAmelCase							:    Optional[Any]  							=							{
    """MIT/ast-finetuned-audioset-10-10-0.4593""": (
        """https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json"""
    ),
}






class 					__magic_name__							( UpperCAmelCase__       ):






				'''simple docstring'''
				__UpperCamelCase    						=		"audio-spectrogram-transformer"





				def __init__( self	,				_a=768	,				_a=12	,				_a=12	,				_a=3_072	,				_a="gelu"	,				_a=0.0	,				_a=0.0	,				_a=0.02	,				_a=1e-1_2	,				_a=16	,				_a=True	,				_a=10	,				_a=10	,				_a=1_024	,				_a=128	,				**_a	,				):





							"""simple docstring"""
							super().__init__(**_a				)

							lowerCamelCase       =      hidden_size
							lowerCamelCase       =      num_hidden_layers
							lowerCamelCase       =      num_attention_heads
							lowerCamelCase       =      intermediate_size
							lowerCamelCase       =      hidden_act
							lowerCamelCase       =      hidden_dropout_prob
							lowerCamelCase       =      attention_probs_dropout_prob
							lowerCamelCase       =      initializer_range
							lowerCamelCase       =      layer_norm_eps
							lowerCamelCase       =      patch_size
							lowerCamelCase       =      qkv_bias
							lowerCamelCase       =      frequency_stride
							lowerCamelCase       =      time_stride
							lowerCamelCase       =      max_length
							lowerCamelCase       =      num_mel_bins



