



'''simple docstring'''






import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
   import tensorflow as tf

   from transformers.activations_tf import get_tf_activation



@require_tf
class 							lowercase (						unittest.TestCase       ):


 """simple docstring"""


 def _snake_case				(							self							)	->     List[Any]:
        _UpperCAmelCase						:		Optional[int]      =				tf.constant([-100, -1.0, -0.1, 0, 0.1, 1.0, 100.0]							)
        _UpperCAmelCase						:		Optional[int]      =				get_tf_activation("""gelu"""							)
        _UpperCAmelCase						:		int      =				get_tf_activation("""gelu_10"""							)

        _UpperCAmelCase						:		str      =				gelu(a_							)
        _UpperCAmelCase						:		List[Any]      =				geluaa(a_							)

        _UpperCAmelCase						:		Optional[Any]      =				tf.where(y_gelu_aa < 10.0						,1.0						,0.0							)

        self.assertEqual(tf.math.reduce_max(a_							).numpy().item()						,10.0							)
        self.assertTrue(np.allclose(y_gelu * clipped_mask						,y_gelu_aa * clipped_mask							)							)







 def _snake_case				(							self							)	->     Tuple:
        get_tf_activation("""gelu"""							)
        get_tf_activation("""gelu_10"""							)
        get_tf_activation("""gelu_fast"""							)
        get_tf_activation("""gelu_new"""							)
        get_tf_activation("""glu"""							)
        get_tf_activation("""mish"""							)
        get_tf_activation("""quick_gelu"""							)
        get_tf_activation("""relu"""							)
        get_tf_activation("""sigmoid"""							)
        get_tf_activation("""silu"""							)
        get_tf_activation("""swish"""							)
        get_tf_activation("""tanh"""							)
        with self.assertRaises(a_							):
               get_tf_activation("""bogus"""							)
        with self.assertRaises(a_							):
               get_tf_activation(a_							)








'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


A_							:				Union[str, Any]						=			{
    """configuration_segformer""": ["""SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SegformerConfig""", """SegformerOnnxConfig"""]
}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							:				Tuple						=			["""SegformerFeatureExtractor"""]
   A_							:				Tuple						=			["""SegformerImageProcessor"""]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							:				Dict						=			[
       """SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """SegformerDecodeHead""",
       """SegformerForImageClassification""",
       """SegformerForSemanticSegmentation""",
       """SegformerLayer""",
       """SegformerModel""",
       """SegformerPreTrainedModel""",
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							:				List[str]						=			[
       """TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """TFSegformerDecodeHead""",
       """TFSegformerForImageClassification""",
       """TFSegformerForSemanticSegmentation""",
       """TFSegformerModel""",
       """TFSegformerPreTrainedModel""",
   ]


if TYPE_CHECKING:
   from .configuration_segformer import SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, SegformerConfig, SegformerOnnxConfig

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .feature_extraction_segformer import SegformerFeatureExtractor
      from .image_processing_segformer import SegformerImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_segformer import (
          SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          SegformerDecodeHead,
          SegformerForImageClassification,
          SegformerForSemanticSegmentation,
          SegformerLayer,
          SegformerModel,
          SegformerPreTrainedModel,
      )
   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_segformer import (
          TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFSegformerDecodeHead,
          TFSegformerForImageClassification,
          TFSegformerForSemanticSegmentation,
          TFSegformerModel,
          TFSegformerPreTrainedModel,
      )

else:
   import sys

   A_							:				Optional[Any]						=			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



