import unittest

import torch
from torch import nn

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







							def 				snake_case  (				self     :    Union[str, Any]		):
										lowerCamelCase						:int						  =     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 				snake_case  (				self     :    Optional[Any]		):
										lowerCamelCase						:Optional[Any]						  =     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 				snake_case  (				self     :    int		):
										lowerCamelCase						:Dict						  =     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 				snake_case  (				self     :    List[str]		):
										lowerCamelCase						:Union[str, 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


A__           =							{
    """configuration_nllb_moe""": [
        """NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """NllbMoeConfig""",
    ]
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			A__           =							[
			    """NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST""",
			    """NllbMoeForConditionalGeneration""",
			    """NllbMoeModel""",
			    """NllbMoePreTrainedModel""",
			    """NllbMoeTop2Router""",
			    """NllbMoeSparseMLP""",
			]


if TYPE_CHECKING:
			from .configuration_nllb_moe import (
			    NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP,
			    NllbMoeConfig,
			)

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_nllb_moe import (
						    NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST,
						    NllbMoeForConditionalGeneration,
						    NllbMoeModel,
						    NllbMoePreTrainedModel,
						    NllbMoeSparseMLP,
						    NllbMoeTopaRouter,
						)


else:
			import sys

			A__           =							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



