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


_UpperCAmelCase :			Tuple              =	logging.get_logger(__name__)

_UpperCAmelCase :			Optional[int]              =	{
    "studio-ousia/luke-base": "https://huggingface.co/studio-ousia/luke-base/resolve/main/config.json",
    "studio-ousia/luke-large": "https://huggingface.co/studio-ousia/luke-large/resolve/main/config.json",
}


class     lowercase (		_SCREAMING_SNAKE_CASE       ):
		__lowercase	:	int     					=    "luke"



		def __init__(			self    ,				A_=50_267    ,				A_=500_000    ,				A_=768    ,				A_=256    ,				A_=12    ,				A_=12    ,				A_=3_072    ,				A_="gelu"    ,				A_=0.1    ,				A_=0.1    ,				A_=512    ,				A_=2    ,				A_=0.02    ,				A_=1e-12    ,				A_=True    ,				A_=None    ,				A_=1    ,				A_=0    ,				A_=2    ,				**A_    ,				)  -> Any:
				"""simple docstring"""
				super().__init__(pad_token_id=A_    ,				bos_token_id=A_    ,				eos_token_id=A_    ,				**A_	)

				UpperCamelCase          =					vocab_size
				UpperCamelCase          =					entity_vocab_size
				UpperCamelCase          =					hidden_size
				UpperCamelCase          =					entity_emb_size
				UpperCamelCase          =					num_hidden_layers
				UpperCamelCase          =					num_attention_heads
				UpperCamelCase          =					hidden_act
				UpperCamelCase          =					intermediate_size
				UpperCamelCase          =					hidden_dropout_prob
				UpperCamelCase          =					attention_probs_dropout_prob
				UpperCamelCase          =					max_position_embeddings
				UpperCamelCase          =					type_vocab_size
				UpperCamelCase          =					initializer_range
				UpperCamelCase          =					layer_norm_eps
				UpperCamelCase          =					use_entity_aware_attention
				UpperCamelCase          =					classifier_dropout


import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation


class     lowercase (		unittest.TestCase       ):



		def __UpperCamelCase			(			self	)  -> List[Any]:
				"""simple docstring"""
				UpperCamelCase          =					get_activation('swish'	)

				self.assertIsInstance(A_    ,				nn.SiLU	)

				self.assertEqual(act(torch.tensor(-100    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertNotEqual(act(torch.tensor(-1    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(0    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(20    ,				dtype=torch.floataa	)	).item()    ,				20	)



		def __UpperCamelCase			(			self	)  -> Optional[int]:
				"""simple docstring"""
				UpperCamelCase          =					get_activation('silu'	)

				self.assertIsInstance(A_    ,				nn.SiLU	)

				self.assertEqual(act(torch.tensor(-100    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertNotEqual(act(torch.tensor(-1    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(0    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(20    ,				dtype=torch.floataa	)	).item()    ,				20	)



		def __UpperCamelCase			(			self	)  -> str:
				"""simple docstring"""
				UpperCamelCase          =					get_activation('mish'	)

				self.assertIsInstance(A_    ,				nn.Mish	)

				self.assertEqual(act(torch.tensor(-200    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertNotEqual(act(torch.tensor(-1    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(0    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(20    ,				dtype=torch.floataa	)	).item()    ,				20	)



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase          =					get_activation('gelu'	)

				self.assertIsInstance(A_    ,				nn.GELU	)

				self.assertEqual(act(torch.tensor(-100    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertNotEqual(act(torch.tensor(-1    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(0    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(20    ,				dtype=torch.floataa	)	).item()    ,				20	)
