






import math

import tensorflow as tf
from packaging import version






def 				lowerCamelCase__				(_UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= tf.convert_to_tensor(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= 0.5 * (1.0 + tf.math.erf(x / tf.cast(tf.sqrt(2.0)							,       x.dtype)))

			return x * cdf






def 				lowerCamelCase__				(_UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= tf.convert_to_tensor(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= tf.cast(math.pi							,       x.dtype)
			SCREAMING_SNAKE_CASE						= tf.cast(0.04_47_15							,       x.dtype)
			SCREAMING_SNAKE_CASE						= 0.5 * (1.0 + tf.tanh(tf.sqrt(2.0 / pi) * (x + coeff * tf.pow(_UpperCAmelCase							,       3))))

			return x * cdf






def 				lowerCamelCase__				(_UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= tf.convert_to_tensor(_UpperCAmelCase)

			return x * tf.tanh(tf.math.softplus(_UpperCAmelCase))






def 				lowerCamelCase__				(_UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= tf.convert_to_tensor(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= tf.cast(0.04_47_15							,       x.dtype)
			SCREAMING_SNAKE_CASE						= tf.cast(0.79_78_84_56_08							,       x.dtype)

			return 0.5 * x * (1.0 + tf.tanh(x * coeffa * (1.0 + coeffa * x * x)))






def 				lowerCamelCase__				(_UpperCAmelCase):
			SCREAMING_SNAKE_CASE						= tf.convert_to_tensor(_UpperCAmelCase)
			SCREAMING_SNAKE_CASE						= tf.cast(1.7_02							,       x.dtype)
			return x * tf.math.sigmoid(coeff * x)






def 				lowerCamelCase__				(_UpperCAmelCase):
			return tf.clip_by_value(_gelu(_UpperCAmelCase)							,       -10							,       10)






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase=-1):
			SCREAMING_SNAKE_CASE				,						SCREAMING_SNAKE_CASE						= tf.split(_UpperCAmelCase							,       2							,       axis=_UpperCAmelCase)
			return a * tf.math.sigmoid(_UpperCAmelCase)


if version.parse(tf.version.VERSION) >= version.parse('2.4'):






				def 				lowerCamelCase__				(_UpperCAmelCase):
							return tf.keras.activations.gelu(_UpperCAmelCase							,       approximate=_UpperCAmelCase)

				a_		:						str             =    tf.keras.activations.gelu







				a_		:						List[str]             =    approximate_gelu_wrap
else:
				a_		:						Union[str, Any]             =    _gelu
				a_		:						str             =    _gelu_new


a_		:						Union[str, Any]             =    {
    'gelu': gelu,
    'gelu_10': gelu_aa,
    'gelu_fast': gelu_fast,
    'gelu_new': gelu_new,
    'glu': glu,
    'mish': mish,
    'quick_gelu': quick_gelu,
    'relu': tf.keras.activations.relu,
    'sigmoid': tf.keras.activations.sigmoid,
    'silu': tf.keras.activations.swish,
    'swish': tf.keras.activations.swish,
    'tanh': tf.keras.activations.tanh,
}







def 				lowerCamelCase__				(_UpperCAmelCase):
			if activation_string in ACTaFN:
						return ACTaFN[activation_string]
			else:
						raise KeyError(F'''function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys())}''')












# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
a_		:						List[str]             =    abspath(join(dirname(__file__), 'src'))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='ignore', category=FutureWarning)






def 				lowerCamelCase__				(_UpperCAmelCase):
			config.addinivalue_line(
			    'markers'							,       'is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested')
			config.addinivalue_line(
			    'markers'							,       'is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested')
			config.addinivalue_line('markers'							,       'is_pipeline_test: mark test to run only when pipelines are tested')
			config.addinivalue_line('markers'							,       'is_staging_test: mark test to run only in the staging environment')
			config.addinivalue_line('markers'							,       'accelerate_tests: mark test that require accelerate')
			config.addinivalue_line('markers'							,       'tool_tests: mark the tool tests that are run on their specific schedule')






def 				lowerCamelCase__				(_UpperCAmelCase):
			from transformers.testing_utils import pytest_addoption_shared

			pytest_addoption_shared(_UpperCAmelCase)






def 				lowerCamelCase__				(_UpperCAmelCase):
			from transformers.testing_utils import pytest_terminal_summary_main

			SCREAMING_SNAKE_CASE						= terminalreporter.config.getoption('--make-reports')
			if make_reports:
						pytest_terminal_summary_main(_UpperCAmelCase							,       id=_UpperCAmelCase)






def 				lowerCamelCase__				(_UpperCAmelCase							,       _UpperCAmelCase):
			# If no tests are collected, pytest exists with code 5, which makes the CI fail.
			if exitstatus == 5:
						SCREAMING_SNAKE_CASE						= 0


# Doctest custom flag to ignore output.
a_		:						List[Any]             =    doctest.register_optionflag('IGNORE_RESULT')

a_		:						Any             =    doctest.OutputChecker

class 		_snake_case  (  A__					):






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a)      ->       List[Any]:
						if IGNORE_RESULT & optionflags:
									return True
						return OutputChecker.check_output(self		,					a		,					a		,					a)



a_		:						int             =    CustomOutputChecker
a_		:						List[str]             =    HfDoctestModule







a_		:						Optional[int]             =    HfDocTestParser




