



"""simple docstring"""




from typing import TYPE_CHECKING

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


lowercase_						=       {"""configuration_opt""": ["""OPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OPTConfig"""]}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase_						=       [
							    """OPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """OPTForCausalLM""",
							    """OPTModel""",
							    """OPTPreTrainedModel""",
							    """OPTForSequenceClassification""",
							    """OPTForQuestionAnswering""",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase_						=       ["""TFOPTForCausalLM""", """TFOPTModel""", """TFOPTPreTrainedModel"""]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase_						=       [
							    """FlaxOPTForCausalLM""",
							    """FlaxOPTModel""",
							    """FlaxOPTPreTrainedModel""",
							]


if TYPE_CHECKING:
							from .configuration_opt import OPT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPTConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_opt import (
														    OPT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    OPTForCausalLM,
														    OPTForQuestionAnswering,
														    OPTForSequenceClassification,
														    OPTModel,
														    OPTPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_opt import TFOPTForCausalLM, TFOPTModel, TFOPTPreTrainedModel

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_opt import FlaxOPTForCausalLM, FlaxOPTModel, FlaxOPTPreTrainedModel

else:
							import sys

							lowercase_						=       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)









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


lowercase_						=       logging.get_logger(__name__)

lowercase_						=       {
    """transfo-xl-wt103""": """https://huggingface.co/transfo-xl-wt103/resolve/main/config.json""",
}
class 			_snake_case     (   lowercase__):
				UpperCamelCase__			:   Optional[Any]       						="""transfo-xl"""
				UpperCamelCase__			:   Dict       						=["""mems"""]
				UpperCamelCase__			:   Optional[int]       						={
				    """n_token""": """vocab_size""",
				    """hidden_size""": """d_model""",
				    """num_attention_heads""": """n_head""",
				    """num_hidden_layers""": """n_layer""",
				}




				def __init__(  self   :  Optional[Any],   __lowercase   :  Optional[Any]=26_7735,   __lowercase   :  int=[2_0000, 4_0000, 20_0000],   __lowercase   :  Union[str, Any]=1024,   __lowercase   :  Tuple=1024,   __lowercase   :  Tuple=16,   __lowercase   :  Optional[Any]=64,   __lowercase   :  str=4096,   __lowercase   :  Optional[int]=4,   __lowercase   :  Union[str, Any]=False,   __lowercase   :  Union[str, Any]=18,   __lowercase   :  List[str]=1600,   __lowercase   :  List[Any]=1000,   __lowercase   :  Union[str, Any]=True,   __lowercase   :  Tuple=True,   __lowercase   :  Optional[Any]=0,   __lowercase   :  List[str]=-1,   __lowercase   :  int=True,   __lowercase   :  Dict=0.1,   __lowercase   :  Union[str, Any]=0.0,   __lowercase   :  str=True,   __lowercase   :  Optional[Any]="normal",   __lowercase   :  str=0.01,   __lowercase   :  Tuple=0.01,   __lowercase   :  List[Any]=0.02,   __lowercase   :  Any=1e-5,   __lowercase   :  Union[str, Any]=0,   **__lowercase   :  Union[str, Any],   ):
							lowercase__   					=			vocab_size
							lowercase__   					=			[]
							self.cutoffs.extend(__lowercase  )
							if proj_share_all_but_first:
										lowercase__   					=			[False] + [True] * len(self.cutoffs  )
							else:
										lowercase__   					=			[False] + [False] * len(self.cutoffs  )
							lowercase__   					=			d_model
							lowercase__   					=			d_embed
							lowercase__   					=			d_head
							lowercase__   					=			d_inner
							lowercase__   					=			div_val
							lowercase__   					=			pre_lnorm
							lowercase__   					=			n_layer
							lowercase__   					=			n_head
							lowercase__   					=			mem_len
							lowercase__   					=			same_length
							lowercase__   					=			attn_type
							lowercase__   					=			clamp_len
							lowercase__   					=			sample_softmax
							lowercase__   					=			adaptive
							lowercase__   					=			dropout
							lowercase__   					=			dropatt
							lowercase__   					=			untie_r
							lowercase__   					=			init
							lowercase__   					=			init_range
							lowercase__   					=			proj_init_std
							lowercase__   					=			init_std
							lowercase__   					=			layer_norm_epsilon
							super().__init__(eos_token_id=__lowercase,   **__lowercase  )




				@property
				def 							A__ (  self   :  Optional[Any]  ):
							# Message copied from Transformer-XL documentation
							logger.info(F'''The model {self.model_type} is one of the few models that has no sequence length limit.'''  )
							return -1




				@max_position_embeddings.setter
				def 							A__ (  self   :  List[str],   __lowercase   :  Union[str, Any]  ):
							# Message copied from Transformer-XL documentation
							raise NotImplementedError(
							    F'''The model {self.model_type} is one of the few models that has no sequence length limit.'''  )




