



"""simple docstring"""
import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation
class 				lowerCamelCase  (			unittest.TestCase				):






					'''simple docstring'''





					def    lowerCAmelCase_				(       self:							Optional[Any]						)   ->	Union[str, Any]:
											snake_case_ :List[str]						=			get_activation("""swish"""						)

											self.assertIsInstance(snake_case						,     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    lowerCAmelCase_				(       self:							Optional[Any]						)   ->	Optional[Any]:
											snake_case_ :Optional[int]						=			get_activation("""silu"""						)

											self.assertIsInstance(snake_case						,     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    lowerCAmelCase_				(       self:							Optional[Any]						)   ->	Any:
											snake_case_ :Optional[Any]						=			get_activation("""mish"""						)

											self.assertIsInstance(snake_case						,     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    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	Optional[Any]:
											snake_case_ :List[Any]						=			get_activation("""gelu"""						)

											self.assertIsInstance(snake_case						,     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						)






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowerCamelCase	:		List[str]							       =   {"""configuration_vit_msn""": ["""VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ViTMSNConfig"""]}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase	:		List[Any]							       =   [
      """VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """ViTMSNModel""",
      """ViTMSNForImageClassification""",
      """ViTMSNPreTrainedModel""",
  ]

if TYPE_CHECKING:
  from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_vit_msn import (
        VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST,
        ViTMSNForImageClassification,
        ViTMSNModel,
        ViTMSNPreTrainedModel,
    )

else:
  import sys

  _lowerCamelCase	:		Tuple							       =   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


