
'''simple docstring'''





import math
from collections import OrderedDict

import torch
from packaging import version
from torch import Tensor, nn

from .utils import logging


a__		: Optional[Any]  							=							logging.get_logger(__name__)


class 			UpperCamelCase__	(     nn.Module):






 def __init__(      self	:Optional[Any]      )					->      Optional[Any]:







       '''simple docstring'''



       super().__init__()
       if version.parse(torch.__version__      ) < version.parse('1.12.0'      ):
             raise ImportError(
                 F'You are using torch=={torch.__version__}, but torch>=1.12.0 is required to use '
                 'PytorchGELUTanh. Please upgrade torch.'      )






 def 						lowercase_    (      self	:Optional[Any]						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return nn.functional.gelu(_A						,					approximate='tanh'      )


class 			UpperCamelCase__	(     nn.Module):






 def 						lowercase_    (      self	:Optional[Any]						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi      ) * (input + 0.044_715 * torch.pow(_A						,					3.0      ))      ))


class 			UpperCamelCase__	(     nn.Module):






 def __init__(      self	:Optional[int]						,					_A	:bool = False      )					->      Tuple:







       '''simple docstring'''



       super().__init__()
       if use_gelu_python:
             __A													=      self._gelu_python
       else:
             __A													=      nn.functional.gelu






 def 						lowercase_    (      self	:int						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return input * 0.5 * (1.0 + torch.erf(input / math.sqrt(2.0      )      ))






 def 						lowercase_    (      self	:Optional[int]						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return self.act(_A      )


class 			UpperCamelCase__	(     nn.Module):






 def 						lowercase_    (      self	:Tuple						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return 0.5 * input * (1.0 + torch.tanh(input * 0.7_978_845_608 * (1.0 + 0.044_715 * input * input)      ))


class 			UpperCamelCase__	(     nn.Module):






 def 						lowercase_    (      self	:Optional[int]						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return input * torch.sigmoid(1.702 * input      )


class 			UpperCamelCase__	(     nn.Module):






 def __init__(      self	:List[str]						,					_A	:float						,					_A	:float      )					->      List[Any]:







       '''simple docstring'''



       if min > max:
             raise ValueError(F'min should be < max (got min: {min}, max: {max})'      )

       super().__init__()
       __A													=      min
       __A													=      max






 def 						lowercase_    (      self	:Dict						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return torch.clip(gelu(_A      )						,					self.min						,					self.max      )


class 			UpperCamelCase__	(     nn.Module):






 def __init__(      self	:Dict      )					->      Optional[int]:







       '''simple docstring'''



       super().__init__()
       __A													=      math.sqrt(2 / math.pi      )






 def 						lowercase_    (      self	:Tuple						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return 0.5 * input * (1 + torch.tanh(self.precomputed_constant * (input + 0.044_715 * torch.pow(_A						,					3      ))      ))


class 			UpperCamelCase__	(     nn.Module):






 def 						lowercase_    (      self	:int						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return nn.functional.silu(_A      )


class 			UpperCamelCase__	(     nn.Module):






 def __init__(      self	:Any      )					->      Optional[int]:







       '''simple docstring'''



       super().__init__()
       if version.parse(torch.__version__      ) < version.parse('1.9.0'      ):
             __A													=      self._mish_python
       else:
             __A													=      nn.functional.mish






 def 						lowercase_    (      self	:Optional[Any]						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return input * torch.tanh(nn.functional.softplus(_A      )      )






 def 						lowercase_    (      self	:Dict						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return self.act(_A      )


class 			UpperCamelCase__	(     nn.Module):






 def 						lowercase_    (      self	:str						,					_A	:Tensor      )					->      Tensor:







       '''simple docstring'''



       return input


class 			UpperCamelCase__	(     nn.Module):






 def 						lowercase_    (      self	:List[str]						,					_A	:Optional[Any]						,					_A	:Tuple=0.707_107						,					_A	:List[str]=0.282_095      )					->      Union[str, Any]:







       '''simple docstring'''



       __A													=      (input - mu).div(sigma * math.sqrt(2.0      )      )
       return 0.5 * (1.0 + torch.erf(_A      ))


class 			UpperCamelCase__	(     nn.Module):






 def 						lowercase_    (      self	:Tuple						,					_A	:Any      )					->      Optional[Any]:







       '''simple docstring'''



       __A													=      nn.functional.relu(_A      )
       __A													=      torch.square(_A      )
       return squared


class 			UpperCamelCase__	(     SCREAMING_SNAKE_CASE):






 def __getitem__(      self	:Any						,					_A	:Optional[int]      )					->      Dict:







       '''simple docstring'''



       __A													=      super().__getitem__(_A      )
       __A						,   __A													=      content if isinstance(_A						,					_A      ) else (content, {})
       return cls(**_A      )
a__		: Optional[int]  							=							{
    "gelu": GELUActivation,
    "gelu_10": (ClippedGELUActivation, {"min": -1_0, "max": 1_0}),
    "gelu_fast": FastGELUActivation,
    "gelu_new": NewGELUActivation,
    "gelu_python": (GELUActivation, {"use_gelu_python": True}),
    "gelu_pytorch_tanh": PytorchGELUTanh,
    "gelu_accurate": AccurateGELUActivation,
    "laplace": LaplaceActivation,
    "linear": LinearActivation,
    "mish": MishActivation,
    "quick_gelu": QuickGELUActivation,
    "relu": nn.ReLU,
    "relu2": ReLUSquaredActivation,
    "relu6": nn.ReLUa,
    "sigmoid": nn.Sigmoid,
    "silu": SiLUActivation,
    "swish": SiLUActivation,
    "tanh": nn.Tanh,
}
a__		: str  							=							ClassInstantier(ACTaCLS)





def 							snake_case				(		UpperCAmelCase						)->      Any:







      """simple docstring"""
      if activation_string in ACTaFN:
            return ACTaFN[activation_string]
      else:
            raise KeyError(f'function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()						)}'						)


# For backwards compatibility with: from activations import gelu_python
a__		: Dict  							=							get_activation("gelu_python")
a__		: int  							=							get_activation("gelu_new")
a__		: Optional[int]  							=							get_activation("gelu")
a__		: Optional[Any]  							=							get_activation("gelu_fast")
a__		: Optional[Any]  							=							get_activation("quick_gelu")
a__		: Dict  							=							get_activation("silu")
a__		: Dict  							=							get_activation("mish")
a__		: int  							=							get_activation("linear")











"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase				:     Dict								=  {
    """configuration_camembert""": ["""CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CamembertConfig""", """CamembertOnnxConfig"""],
}

try:
    if not is_sentencepiece_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase				:     Optional[Any]								=  ["""CamembertTokenizer"""]

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase				:     Optional[Any]								=  ["""CamembertTokenizerFast"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase				:     int								=  [
        """CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """CamembertForCausalLM""",
        """CamembertForMaskedLM""",
        """CamembertForMultipleChoice""",
        """CamembertForQuestionAnswering""",
        """CamembertForSequenceClassification""",
        """CamembertForTokenClassification""",
        """CamembertModel""",
        """CamembertPreTrainedModel""",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCamelCase				:     str								=  [
        """TF_CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """TFCamembertForCausalLM""",
        """TFCamembertForMaskedLM""",
        """TFCamembertForMultipleChoice""",
        """TFCamembertForQuestionAnswering""",
        """TFCamembertForSequenceClassification""",
        """TFCamembertForTokenClassification""",
        """TFCamembertModel""",
        """TFCamembertPreTrainedModel""",
    ]


if TYPE_CHECKING:
    from .configuration_camembert import CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CamembertConfig, CamembertOnnxConfig

    try:
        if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_camembert import CamembertTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_camembert_fast import CamembertTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_camembert import (
            CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            CamembertForCausalLM,
            CamembertForMaskedLM,
            CamembertForMultipleChoice,
            CamembertForQuestionAnswering,
            CamembertForSequenceClassification,
            CamembertForTokenClassification,
            CamembertModel,
            CamembertPreTrainedModel,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_camembert import (
            TF_CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFCamembertForCausalLM,
            TFCamembertForMaskedLM,
            TFCamembertForMultipleChoice,
            TFCamembertForQuestionAnswering,
            TFCamembertForSequenceClassification,
            TFCamembertForTokenClassification,
            TFCamembertModel,
            TFCamembertPreTrainedModel,
        )

else:
    import sys

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