


import os
import unittest

from transformers import RealmTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.models.realm.tokenization_realm import RealmTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class       __lowerCAmelCase       (	a	,					unittest.TestCase   ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE						      =    RealmTokenizer
  _SCREAMING_SNAKE_CASE						      =    RealmTokenizerFast
  _SCREAMING_SNAKE_CASE						      =    True
  _SCREAMING_SNAKE_CASE						      =    True
  _SCREAMING_SNAKE_CASE						      =    filter_non_english



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




      """simple docstring"""
      super().setUp()

      snake_case_         =   [
          "[UNK]",
          "[CLS]",
          "[SEP]",
          "[PAD]",
          "[MASK]",
          "want",
          "##want",
          "##ed",
          "wa",
          "un",
          "runn",
          "##ing",
          ",",
          "low",
          "lowest",
      ]
      snake_case_         =   os.path.join(self.tmpdirname      ,			VOCAB_FILES_NAMES["vocab_file"]					)
      with open(self.vocab_file      ,			"w"      ,			encoding="utf-8"					) as vocab_writer:
          vocab_writer.write("".join([x + "\n" for x in vocab_tokens]					)					)



  def    lowerCAmelCase__					(       self    :    List[Any]      ,			_lowerCAmelCase    :    Tuple					)				->	str:




      """simple docstring"""
      snake_case_         =   "UNwant\u00E9d,running"
      snake_case_         =   "unwanted, running"
      return input_text, output_text



  def    lowerCAmelCase__					(       self    :    Union[str, Any]					)				->	Optional[int]:




      """simple docstring"""
      snake_case_         =   self.tokenizer_class(self.vocab_file					)

      snake_case_         =   tokenizer.tokenize("UNwant\u00E9d,running"					)
      self.assertListEqual(_lowerCAmelCase      ,			["un", "##want", "##ed", ",", "runn", "##ing"]					)
      self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCAmelCase					)      ,			[9, 6, 7, 1_2, 1_0, 1_1]					)



  def    lowerCAmelCase__					(       self    :    Optional[Any]					)				->	Union[str, Any]:




      """simple docstring"""
      if not self.test_rust_tokenizer:
          return

      snake_case_         =   self.get_tokenizer()
      snake_case_         =   self.get_rust_tokenizer()

      snake_case_         =   "UNwant\u00E9d,running"

      snake_case_         =   tokenizer.tokenize(_lowerCAmelCase					)
      snake_case_         =   rust_tokenizer.tokenize(_lowerCAmelCase					)
      self.assertListEqual(_lowerCAmelCase      ,			_lowerCAmelCase					)

      snake_case_         =   tokenizer.encode(_lowerCAmelCase      ,			add_special_tokens=_lowerCAmelCase					)
      snake_case_         =   rust_tokenizer.encode(_lowerCAmelCase      ,			add_special_tokens=_lowerCAmelCase					)
      self.assertListEqual(_lowerCAmelCase      ,			_lowerCAmelCase					)

      snake_case_         =   self.get_rust_tokenizer()
      snake_case_         =   tokenizer.encode(_lowerCAmelCase					)
      snake_case_         =   rust_tokenizer.encode(_lowerCAmelCase					)
      self.assertListEqual(_lowerCAmelCase      ,			_lowerCAmelCase					)

      # With lower casing
      snake_case_         =   self.get_tokenizer(do_lower_case=_lowerCAmelCase					)
      snake_case_         =   self.get_rust_tokenizer(do_lower_case=_lowerCAmelCase					)

      snake_case_         =   "UNwant\u00E9d,running"

      snake_case_         =   tokenizer.tokenize(_lowerCAmelCase					)
      snake_case_         =   rust_tokenizer.tokenize(_lowerCAmelCase					)
      self.assertListEqual(_lowerCAmelCase      ,			_lowerCAmelCase					)

      snake_case_         =   tokenizer.encode(_lowerCAmelCase      ,			add_special_tokens=_lowerCAmelCase					)
      snake_case_         =   rust_tokenizer.encode(_lowerCAmelCase      ,			add_special_tokens=_lowerCAmelCase					)
      self.assertListEqual(_lowerCAmelCase      ,			_lowerCAmelCase					)

      snake_case_         =   self.get_rust_tokenizer()
      snake_case_         =   tokenizer.encode(_lowerCAmelCase					)
      snake_case_         =   rust_tokenizer.encode(_lowerCAmelCase					)
      self.assertListEqual(_lowerCAmelCase      ,			_lowerCAmelCase					)



  def    lowerCAmelCase__					(       self    :    Any					)				->	int:




      """simple docstring"""
      snake_case_         =   BasicTokenizer()

      self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"					)      ,			["ah", "\u535A", "\u63A8", "zz"]					)



  def    lowerCAmelCase__					(       self    :    Union[str, Any]					)				->	str:




      """simple docstring"""
      snake_case_         =   BasicTokenizer(do_lower_case=_lowerCAmelCase					)

      self.assertListEqual(
          tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "					)      ,			["hello", "!", "how", "are", "you", "?"]					)
      self.assertListEqual(tokenizer.tokenize("H\u00E9llo"					)      ,			["hello"]					)



  def    lowerCAmelCase__					(       self    :    List[Any]					)				->	Dict:




      """simple docstring"""
      snake_case_         =   BasicTokenizer(do_lower_case=_lowerCAmelCase      ,			strip_accents=_lowerCAmelCase					)

      self.assertListEqual(
          tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "					)      ,			["hällo", "!", "how", "are", "you", "?"]					)
      self.assertListEqual(tokenizer.tokenize("H\u00E9llo"					)      ,			["h\u00E9llo"]					)



  def    lowerCAmelCase__					(       self    :    List[Any]					)				->	Union[str, Any]:




      """simple docstring"""
      snake_case_         =   BasicTokenizer(do_lower_case=_lowerCAmelCase      ,			strip_accents=_lowerCAmelCase					)

      self.assertListEqual(
          tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "					)      ,			["hallo", "!", "how", "are", "you", "?"]					)
      self.assertListEqual(tokenizer.tokenize("H\u00E9llo"					)      ,			["hello"]					)



  def    lowerCAmelCase__					(       self    :    List[str]					)				->	Tuple:




      """simple docstring"""
      snake_case_         =   BasicTokenizer(do_lower_case=_lowerCAmelCase					)

      self.assertListEqual(
          tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "					)      ,			["hallo", "!", "how", "are", "you", "?"]					)
      self.assertListEqual(tokenizer.tokenize("H\u00E9llo"					)      ,			["hello"]					)



  def    lowerCAmelCase__					(       self    :    str					)				->	Dict:




      """simple docstring"""
      snake_case_         =   BasicTokenizer(do_lower_case=_lowerCAmelCase					)

      self.assertListEqual(
          tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "					)      ,			["HeLLo", "!", "how", "Are", "yoU", "?"]					)



  def    lowerCAmelCase__					(       self    :    Optional[int]					)				->	Optional[int]:




      """simple docstring"""
      snake_case_         =   BasicTokenizer(do_lower_case=_lowerCAmelCase      ,			strip_accents=_lowerCAmelCase					)

      self.assertListEqual(
          tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "					)      ,			["HäLLo", "!", "how", "Are", "yoU", "?"]					)



  def    lowerCAmelCase__					(       self    :    str					)				->	Optional[Any]:




      """simple docstring"""
      snake_case_         =   BasicTokenizer(do_lower_case=_lowerCAmelCase      ,			strip_accents=_lowerCAmelCase					)

      self.assertListEqual(
          tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "					)      ,			["HaLLo", "!", "how", "Are", "yoU", "?"]					)



  def    lowerCAmelCase__					(       self    :    Optional[Any]					)				->	Dict:




      """simple docstring"""
      snake_case_         =   BasicTokenizer(do_lower_case=_lowerCAmelCase      ,			never_split=["[UNK]"]					)

      self.assertListEqual(
          tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"					)      ,			["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]					)



  def    lowerCAmelCase__					(       self    :    Optional[int]					)				->	Union[str, Any]:




      """simple docstring"""
      snake_case_         =   ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

      snake_case_         =   {}
      for i, token in enumerate(_lowerCAmelCase					):
          snake_case_         =   i
      snake_case_         =   WordpieceTokenizer(vocab=_lowerCAmelCase      ,			unk_token="[UNK]"					)

      self.assertListEqual(tokenizer.tokenize(""					)      ,			[]					)

      self.assertListEqual(tokenizer.tokenize("unwanted running"					)      ,			["un", "##want", "##ed", "runn", "##ing"]					)

      self.assertListEqual(tokenizer.tokenize("unwantedX running"					)      ,			["[UNK]", "runn", "##ing"]					)



  def    lowerCAmelCase__					(       self    :    List[str]					)				->	Optional[Any]:




      """simple docstring"""
      self.assertTrue(_is_whitespace(" "					)					)
      self.assertTrue(_is_whitespace("\t"					)					)
      self.assertTrue(_is_whitespace("\r"					)					)
      self.assertTrue(_is_whitespace("\n"					)					)
      self.assertTrue(_is_whitespace("\u00A0"					)					)

      self.assertFalse(_is_whitespace("A"					)					)
      self.assertFalse(_is_whitespace("-"					)					)



  def    lowerCAmelCase__					(       self    :    List[str]					)				->	str:




      """simple docstring"""
      self.assertTrue(_is_control("\u0005"					)					)

      self.assertFalse(_is_control("A"					)					)
      self.assertFalse(_is_control(" "					)					)
      self.assertFalse(_is_control("\t"					)					)
      self.assertFalse(_is_control("\r"					)					)



  def    lowerCAmelCase__					(       self    :    List[Any]					)				->	Dict:




      """simple docstring"""
      self.assertTrue(_is_punctuation("-"					)					)
      self.assertTrue(_is_punctuation("$"					)					)
      self.assertTrue(_is_punctuation("`"					)					)
      self.assertTrue(_is_punctuation("."					)					)

      self.assertFalse(_is_punctuation("A"					)					)
      self.assertFalse(_is_punctuation(" "					)					)



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




      """simple docstring"""
      snake_case_         =   self.get_tokenizer()

      # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
      self.assertListEqual([tokenizer.tokenize(_lowerCAmelCase					) for t in ["Test", "\xad", "test"]]      ,			[["[UNK]"], [], ["[UNK]"]]					)

      if self.test_rust_tokenizer:
          snake_case_         =   self.get_rust_tokenizer()
          self.assertListEqual(
              [rust_tokenizer.tokenize(_lowerCAmelCase					) for t in ["Test", "\xad", "test"]]      ,			[["[UNK]"], [], ["[UNK]"]]					)



  @slow
  def    lowerCAmelCase__					(       self    :    Union[str, Any]					)				->	Dict:




      """simple docstring"""
      snake_case_         =   self.tokenizer_class.from_pretrained("bert-base-uncased"					)

      snake_case_         =   tokenizer.encode("sequence builders"      ,			add_special_tokens=_lowerCAmelCase					)
      snake_case_         =   tokenizer.encode("multi-sequence build"      ,			add_special_tokens=_lowerCAmelCase					)

      snake_case_         =   tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase					)
      snake_case_         =   tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase      ,			_lowerCAmelCase					)

      assert encoded_sentence == [1_0_1] + text + [1_0_2]
      assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]



  def    lowerCAmelCase__					(       self    :    List[Any]					)				->	List[Any]:




      """simple docstring"""
      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
              snake_case_         =   self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase      ,			**_lowerCAmelCase					)

              snake_case_         =   F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
              snake_case_         =   tokenizer_r.encode_plus(
                  _lowerCAmelCase      ,			return_attention_mask=_lowerCAmelCase      ,			return_token_type_ids=_lowerCAmelCase      ,			return_offsets_mapping=_lowerCAmelCase      ,			add_special_tokens=_lowerCAmelCase      ,			)

              snake_case_         =   tokenizer_r.do_lower_case if hasattr(_lowerCAmelCase      ,			"do_lower_case"					) else False
              snake_case_         =   (
                  [
                      ((0, 0), tokenizer_r.cls_token),
                      ((0, 1), "A"),
                      ((1, 2), ","),
                      ((3, 5), "na"),
                      ((5, 6), "##ï"),
                      ((6, 8), "##ve"),
                      ((9, 1_5), tokenizer_r.mask_token),
                      ((1_6, 2_1), "Allen"),
                      ((2_1, 2_3), "##NL"),
                      ((2_3, 2_4), "##P"),
                      ((2_5, 3_3), "sentence"),
                      ((3_3, 3_4), "."),
                      ((0, 0), tokenizer_r.sep_token),
                  ]
                  if not do_lower_case
                  else [
                      ((0, 0), tokenizer_r.cls_token),
                      ((0, 1), "a"),
                      ((1, 2), ","),
                      ((3, 8), "naive"),
                      ((9, 1_5), tokenizer_r.mask_token),
                      ((1_6, 2_1), "allen"),
                      ((2_1, 2_3), "##nl"),
                      ((2_3, 2_4), "##p"),
                      ((2_5, 3_3), "sentence"),
                      ((3_3, 3_4), "."),
                      ((0, 0), tokenizer_r.sep_token),
                  ]
              )

              self.assertEqual(
                  [e[1] for e in expected_results]      ,			tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]					)					)
              self.assertEqual([e[0] for e in expected_results]      ,			tokens["offset_mapping"]					)



  @slow
  def    lowerCAmelCase__					(       self    :    Optional[int]					)				->	Dict:




      """simple docstring"""
      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
              snake_case_         =   self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase      ,			**_lowerCAmelCase					)
              snake_case_         =   self.tokenizer_class.from_pretrained(_lowerCAmelCase      ,			**_lowerCAmelCase					)
              snake_case_         =   [["Hello world!", "Nice to meet you!"], ["The cute cat.", "The adorable dog."]]

              snake_case_         =   tokenizer_r.batch_encode_candidates(_lowerCAmelCase      ,			max_length=1_0      ,			return_tensors="np"					)
              snake_case_         =   tokenizer_p.batch_encode_candidates(_lowerCAmelCase      ,			max_length=1_0      ,			return_tensors="np"					)

              snake_case_         =   (2, 2, 1_0)

              self.assertEqual(encoded_sentence_r["input_ids"].shape      ,			_lowerCAmelCase					)
              self.assertEqual(encoded_sentence_r["attention_mask"].shape      ,			_lowerCAmelCase					)
              self.assertEqual(encoded_sentence_r["token_type_ids"].shape      ,			_lowerCAmelCase					)

              self.assertEqual(encoded_sentence_p["input_ids"].shape      ,			_lowerCAmelCase					)
              self.assertEqual(encoded_sentence_p["attention_mask"].shape      ,			_lowerCAmelCase					)
              self.assertEqual(encoded_sentence_p["token_type_ids"].shape      ,			_lowerCAmelCase					)








import math
from collections import OrderedDict

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

from .utils import logging


SCREAMING_SNAKE_CASE		:Tuple											=       logging.get_logger(__name__)


class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





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




     """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    lowerCAmelCase__					(       self    :    Optional[int]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return nn.functional.gelu(_lowerCAmelCase      ,			approximate="tanh"					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    int      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




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






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def __init__(       self    :    int      ,			_lowerCAmelCase    :    bool = False					)				->	int:




     """simple docstring"""
     super().__init__()
     if use_gelu_python:
        snake_case_         =   self._gelu_python
     else:
        snake_case_         =   nn.functional.gelu



  def    lowerCAmelCase__					(       self    :    Optional[Any]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




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



  def    lowerCAmelCase__					(       self    :    Dict      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return self.act(_lowerCAmelCase					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    Optional[int]      ,			_lowerCAmelCase    :    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       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    int      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return input * torch.sigmoid(1.702 * input					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





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




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

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



  def    lowerCAmelCase__					(       self    :    Union[str, Any]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return torch.clip(gelu(_lowerCAmelCase					)      ,			self.min      ,			self.max					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def __init__(       self    :    Any					)				->	str:




     """simple docstring"""
     super().__init__()
     snake_case_         =   math.sqrt(2 / math.pi					)



  def    lowerCAmelCase__					(       self    :    Optional[Any]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return 0.5 * input * (1 + torch.tanh(self.precomputed_constant * (input + 0.044_715 * torch.pow(_lowerCAmelCase      ,			3					))					))






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    str      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return nn.functional.silu(_lowerCAmelCase					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





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




     """simple docstring"""
     super().__init__()
     if version.parse(torch.__version__					) < version.parse("1.9.0"					):
        snake_case_         =   self._mish_python
     else:
        snake_case_         =   nn.functional.mish



  def    lowerCAmelCase__					(       self    :    Tuple      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return input * torch.tanh(nn.functional.softplus(_lowerCAmelCase					)					)



  def    lowerCAmelCase__					(       self    :    Optional[Any]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return self.act(_lowerCAmelCase					)






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    List[str]      ,			_lowerCAmelCase    :    Tensor					)				->	Tensor:




     """simple docstring"""
     return input






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    List[Any]      ,			_lowerCAmelCase    :    List[Any]      ,			_lowerCAmelCase    :    Union[str, Any]=0.707_107      ,			_lowerCAmelCase    :    int=0.282_095					)				->	List[str]:




     """simple docstring"""
     snake_case_         =   (input - mu).div(sigma * math.sqrt(2.0					)					)
     return 0.5 * (1.0 + torch.erf(_lowerCAmelCase					))






class       __lowerCAmelCase       (	nn.Module   ):






  """simple docstring"""





  def    lowerCAmelCase__					(       self    :    Any      ,			_lowerCAmelCase    :    Union[str, Any]					)				->	Any:




     """simple docstring"""
     snake_case_         =   nn.functional.relu(_lowerCAmelCase					)
     snake_case_         =   torch.square(_lowerCAmelCase					)
     return squared






class       __lowerCAmelCase       (	a   ):






  """simple docstring"""





  def __getitem__(       self    :    Optional[Any]      ,			_lowerCAmelCase    :    str					)				->	Optional[int]:




     """simple docstring"""
     snake_case_         =   super().__getitem__(_lowerCAmelCase					)
     snake_case_      ,      snake_case_         =   content if isinstance(_lowerCAmelCase      ,			_lowerCAmelCase					) else (content, {})
     return cls(**_lowerCAmelCase					)






SCREAMING_SNAKE_CASE		:Optional[int]											=       {
    '''gelu''': GELUActivation,
    '''gelu_10''': (ClippedGELUActivation, {'''min''': -10, '''max''': 10}),
    '''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,
}
SCREAMING_SNAKE_CASE		:Optional[int]											=       ClassInstantier(ACTaCLS)



def      _lowerCAmelCase  (							lowerCAmelCase_							:Optional[Any]							)->Union[str, 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
SCREAMING_SNAKE_CASE		:Tuple											=       get_activation('''gelu_python''')
SCREAMING_SNAKE_CASE		:int											=       get_activation('''gelu_new''')
SCREAMING_SNAKE_CASE		:List[Any]											=       get_activation('''gelu''')
SCREAMING_SNAKE_CASE		:int											=       get_activation('''gelu_fast''')
SCREAMING_SNAKE_CASE		:Tuple											=       get_activation('''quick_gelu''')
SCREAMING_SNAKE_CASE		:Tuple											=       get_activation('''silu''')
SCREAMING_SNAKE_CASE		:Any											=       get_activation('''mish''')



SCREAMING_SNAKE_CASE		:Optional[Any]											=       get_activation('''linear''')




