"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_a					:					List[Any]=			{
    "configuration_swinv2": ["SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP", "Swinv2Config"],
}


try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_a					:					Tuple=			[
	    "SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "Swinv2ForImageClassification",
	    "Swinv2ForMaskedImageModeling",
	    "Swinv2Model",
	    "Swinv2PreTrainedModel",
	]


if TYPE_CHECKING:
	from .configuration_swinva import SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinvaConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_swinva import (
		    SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST,
		    SwinvaForImageClassification,
		    SwinvaForMaskedImageModeling,
		    SwinvaModel,
		    SwinvaPreTrainedModel,
		)


else:
	import sys

	_a					:					Optional[int]=			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






"""simple docstring"""







from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig


_a					:					Tuple=			{
    "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/config.json",
    "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/config.json",
    "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/config.json",
    "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/config.json",
    "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/config.json",
    "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/config.json",
    "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/config.json",
    "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/config.json",
}

class 		UpperCamelCase      (   lowercase						):
				UpperCAmelCase    :				str   =		"""albert"""



				def __init__(self    :				Union[str, Any]     ,  _A    :				int=3_00_00     ,  _A    :				Any=1_28     ,  _A    :				Tuple=40_96     ,  _A    :				int=12     ,  _A    :				Tuple=1     ,  _A    :				int=64     ,  _A    :				Optional[Any]=1_63_84     ,  _A    :				Optional[Any]=1     ,  _A    :				List[str]="gelu_new"     ,  _A    :				Any=0     ,  _A    :				Optional[Any]=0     ,  _A    :				List[Any]=5_12     ,  _A    :				List[Any]=2     ,  _A    :				Dict=0.02     ,  _A    :				Union[str, Any]=1E-12     ,  _A    :				Tuple=0.1     ,  _A    :				int="absolute"     ,  _A    :				List[Any]=0     ,  _A    :				str=2     ,  _A    :				int=3     ,  **_A    :				Tuple     ,  )   ->     Union[str, Any]:
					super().__init__(pad_token_id=_A     ,  bos_token_id=_A     ,  eos_token_id=_A     ,  **_A)

					__snake_case      :							str						=			vocab_size
					__snake_case      :							List[Any]						=			embedding_size
					__snake_case      :							Tuple						=			hidden_size
					__snake_case      :							Optional[Any]						=			num_hidden_layers
					__snake_case      :							List[str]						=			num_hidden_groups
					__snake_case      :							Dict						=			num_attention_heads
					__snake_case      :							Any						=			inner_group_num
					__snake_case      :							Union[str, Any]						=			hidden_act
					__snake_case      :							List[Any]						=			intermediate_size
					__snake_case      :							List[str]						=			hidden_dropout_prob
					__snake_case      :							int						=			attention_probs_dropout_prob
					__snake_case      :							Any						=			max_position_embeddings
					__snake_case      :							Optional[int]						=			type_vocab_size
					__snake_case      :							Optional[Any]						=			initializer_range
					__snake_case      :							List[Any]						=			layer_norm_eps
					__snake_case      :							Optional[Any]						=			classifier_dropout_prob
					__snake_case      :							List[str]						=			position_embedding_type







class 		UpperCamelCase      (   lowercase						):



				@property
				def  _lowercase					(self    :				Tuple)   ->     Mapping[str, Mapping[int, str]]:
					if self.task == "multiple-choice":
						__snake_case      :							int						=			{0: 'batch', 1: 'choice', 2: 'sequence'}
					else:
						__snake_case      :							Optional[Any]						=			{0: 'batch', 1: 'sequence'}
					return OrderedDict(
					    [
					        ('input_ids', dynamic_axis),
					        ('attention_mask', dynamic_axis),
					        ('token_type_ids', dynamic_axis),
					    ])





