






import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation






class 		lowercase_					(	unittest.TestCase   ):






      '''simple docstring'''




      def       __lowerCAmelCase					(      self      :						Optional[int]  )    ->Tuple:




       """simple docstring"""


       a		  =      get_activation('''swish'''  )

       self.assertIsInstance(__UpperCAmelCase ,					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      :						Dict  )    ->Dict:




       """simple docstring"""


       a		  =      get_activation('''silu'''  )

       self.assertIsInstance(__UpperCAmelCase ,					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      :						Union[str, Any]  )    ->int:




       """simple docstring"""


       a		  =      get_activation('''mish'''  )

       self.assertIsInstance(__UpperCAmelCase ,					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      :						Tuple  )    ->Optional[int]:




       """simple docstring"""


       a		  =      get_activation('''gelu'''  )

       self.assertIsInstance(__UpperCAmelCase ,					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_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


_lowerCAmelCase					:			Tuple  				=			{
    "configuration_llama": ["LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "LlamaConfig"],
}

try:
						if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCAmelCase					:			Optional[int]  				=			["LlamaTokenizer"]

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCAmelCase					:			Optional[int]  				=			["LlamaTokenizerFast"]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCAmelCase					:			List[Any]  				=			[
						    "LlamaForCausalLM",
						    "LlamaModel",
						    "LlamaPreTrainedModel",
						    "LlamaForSequenceClassification",
						]


if TYPE_CHECKING:
						from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig

						try:
												if not is_sentencepiece_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_llama import LlamaTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_llama_fast import LlamaTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel


else:
						import sys

						_lowerCAmelCase					:			int  				=			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






