
"""simple docstring"""





import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
		import torch

		from transformers.activations import gelu_new, gelu_python, get_activation



@require_torch
class __lowerCAmelCase				(					unittest.TestCase      ):




			"""simple docstring"""







			def      lowerCamelCase__     (				self						:					Optional[int]	)      -> Any:







								"""simple docstring"""
								A_				 =						torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]	)
								A_				 =						get_activation("gelu"	)
								self.assertTrue(torch.allclose(gelu_python(_A	)       ,   torch_builtin(_A	)	)	)
								self.assertFalse(torch.allclose(gelu_python(_A	)       ,   gelu_new(_A	)	)	)




			def      lowerCamelCase__     (				self						:					int	)      -> Tuple:







								"""simple docstring"""
								A_				 =						torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]	)
								A_				 =						get_activation("gelu"	)
								A_				 =						get_activation("gelu_10"	)

								A_				 =						torch_builtin(_A	)
								A_				 =						geluaa(_A	)

								A_				 =						torch.where(y_gelu_aa < 1_0.0       ,   1       ,   0	)

								self.assertTrue(torch.max(_A	).item() == 1_0.0	)
								self.assertTrue(torch.allclose(y_gelu * clipped_mask       ,   y_gelu_aa * clipped_mask	)	)




			def      lowerCamelCase__     (				self						:					int	)      -> int:







								"""simple docstring"""
								get_activation("gelu"	)
								get_activation("gelu_10"	)
								get_activation("gelu_fast"	)
								get_activation("gelu_new"	)
								get_activation("gelu_python"	)
								get_activation("gelu_pytorch_tanh"	)
								get_activation("linear"	)
								get_activation("mish"	)
								get_activation("quick_gelu"	)
								get_activation("relu"	)
								get_activation("sigmoid"	)
								get_activation("silu"	)
								get_activation("swish"	)
								get_activation("tanh"	)
								with self.assertRaises(_A	):
													get_activation("bogus"	)
								with self.assertRaises(_A	):
													get_activation(_A	)






			def      lowerCamelCase__     (				self						:					List[Any]	)      -> Tuple:







								"""simple docstring"""
								A_				 =						get_activation("gelu"	)
								A_				 =						1
								A_				 =						get_activation("gelu"	)
								self.assertEqual(acta.a       ,   1	)
								with self.assertRaises(_A	):
													A_				 =						acta.a






"""simple docstring"""





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


UpperCamelCase_					:						Tuple				= logging.get_logger(__name__)

UpperCamelCase_					:						Optional[int]				= {
    '''microsoft/markuplm-base''': '''https://huggingface.co/microsoft/markuplm-base/resolve/main/config.json''',
    '''microsoft/markuplm-large''': '''https://huggingface.co/microsoft/markuplm-large/resolve/main/config.json''',
}



class __lowerCAmelCase				(					_lowercase      ):




			"""simple docstring"""







			snake_case	      =				"markuplm"




			def __init__(				self						:					Optional[Any]       ,   _snake_case						:					Dict=30_522       ,   _snake_case						:					str=768       ,   _snake_case						:					Tuple=12       ,   _snake_case						:					Union[str, Any]=12       ,   _snake_case						:					Union[str, Any]=3_072       ,   _snake_case						:					List[str]="gelu"       ,   _snake_case						:					List[str]=0.1       ,   _snake_case						:					Optional[Any]=0.1       ,   _snake_case						:					Dict=512       ,   _snake_case						:					Union[str, Any]=2       ,   _snake_case						:					Tuple=0.0_2       ,   _snake_case						:					Tuple=1e-12       ,   _snake_case						:					Tuple=0       ,   _snake_case						:					Tuple=0       ,   _snake_case						:					Optional[Any]=2       ,   _snake_case						:					int=256       ,   _snake_case						:					Dict=1_024       ,   _snake_case						:					List[str]=216       ,   _snake_case						:					Optional[int]=1_001       ,   _snake_case						:					Union[str, Any]=32       ,   _snake_case						:					List[str]=50       ,   _snake_case						:					str="absolute"       ,   _snake_case						:					Optional[Any]=True       ,   _snake_case						:					str=None       ,   **_snake_case						:					Optional[Any]       ,   )      -> Optional[Any]:







								"""simple docstring"""
								super().__init__(
								    pad_token_id=_snake_case       ,   bos_token_id=_snake_case       ,   eos_token_id=_snake_case       ,   **_snake_case       ,   )
								A_				 =						vocab_size
								A_				 =						hidden_size
								A_				 =						num_hidden_layers
								A_				 =						num_attention_heads
								A_				 =						hidden_act
								A_				 =						intermediate_size
								A_				 =						hidden_dropout_prob
								A_				 =						attention_probs_dropout_prob
								A_				 =						max_position_embeddings
								A_				 =						type_vocab_size
								A_				 =						initializer_range
								A_				 =						layer_norm_eps
								A_				 =						position_embedding_type
								A_				 =						use_cache
								A_				 =						classifier_dropout
								# additional properties
								A_				 =						max_depth
								A_				 =						max_xpath_tag_unit_embeddings
								A_				 =						max_xpath_subs_unit_embeddings
								A_				 =						tag_pad_id
								A_				 =						subs_pad_id
								A_				 =						xpath_unit_hidden_size




