'''simple docstring'''




from ...configuration_utils import PretrainedConfig
from ...utils import logging


__SCREAMING_SNAKE_CASE :  Any  =						logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE :  Optional[int]  =						{
    """tau/splinter-base""": """https://huggingface.co/tau/splinter-base/resolve/main/config.json""",
    """tau/splinter-base-qass""": """https://huggingface.co/tau/splinter-base-qass/resolve/main/config.json""",
    """tau/splinter-large""": """https://huggingface.co/tau/splinter-large/resolve/main/config.json""",
    """tau/splinter-large-qass""": """https://huggingface.co/tau/splinter-large-qass/resolve/main/config.json""",
    # See all Splinter models at https://huggingface.co/models?filter=splinter
}

class 			lowerCamelCase_			(snake_case__					):
      '''simple docstring'''

      __UpperCamelCase:						Dict      			=		"splinter"




      def __init__( self		:       str		,      A		:       Tuple=30522		,      A		:       int=768		,      A		:       str=12		,      A		:       Optional[int]=12		,      A		:       List[Any]=3072		,      A		:       int="gelu"		,      A		:       str=0.1		,      A		:       Optional[int]=0.1		,      A		:       int=512		,      A		:       List[str]=2		,      A		:       Dict=0.02		,      A		:       int=1E-12		,      A		:       int=True		,      A		:       Any=0		,      A		:       Union[str, Any]=104		,      **A		:       int		,      ):
             super().__init__(pad_token_id=A		,      **A )

             _UpperCAmelCase  :						int							   =					vocab_size
             _UpperCAmelCase  :						Optional[Any]							   =					max_position_embeddings
             _UpperCAmelCase  :						Optional[int]							   =					hidden_size
             _UpperCAmelCase  :						Union[str, Any]							   =					num_hidden_layers
             _UpperCAmelCase  :						Union[str, Any]							   =					num_attention_heads
             _UpperCAmelCase  :						int							   =					intermediate_size
             _UpperCAmelCase  :						Union[str, Any]							   =					hidden_act
             _UpperCAmelCase  :						Union[str, Any]							   =					hidden_dropout_prob
             _UpperCAmelCase  :						Any							   =					attention_probs_dropout_prob
             _UpperCAmelCase  :						Tuple							   =					initializer_range
             _UpperCAmelCase  :						str							   =					type_vocab_size
             _UpperCAmelCase  :						str							   =					layer_norm_eps
             _UpperCAmelCase  :						Optional[Any]							   =					use_cache
             _UpperCAmelCase  :						Union[str, Any]							   =					question_token_id


'''simple docstring'''




from typing import TYPE_CHECKING

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


__SCREAMING_SNAKE_CASE :  Union[str, Any]  =						{
    """configuration_gptsan_japanese""": ["""GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTSanJapaneseConfig"""],
    """tokenization_gptsan_japanese""": ["""GPTSanJapaneseTokenizer"""],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __SCREAMING_SNAKE_CASE :  Optional[int]  =						[
      """GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """GPTSanJapaneseForConditionalGeneration""",
      """GPTSanJapaneseModel""",
      """GPTSanJapanesePreTrainedModel""",
  ]
  __SCREAMING_SNAKE_CASE :  Union[str, Any]  =						[
      """GPTSanJapaneseTokenizer""",
  ]


if TYPE_CHECKING:
  from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
  from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_gptsan_japanese import (
        GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
        GPTSanJapaneseForConditionalGeneration,
        GPTSanJapaneseModel,
        GPTSanJapanesePreTrainedModel,
    )
    from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
  import sys

  __SCREAMING_SNAKE_CASE :  Union[str, Any]  =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

