"""simple docstring"""







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


_a  :  Any=				logging.get_logger(__name__)

_a  :  List[Any]=				{
    """caidas/swin2sr-classicalsr-x2-64""": (
        """https://huggingface.co/caidas/swin2sr-classicalsr-x2-64/resolve/main/config.json"""
    ),
}

class 	UpperCamelCase    (					UpperCamelCase_		):
				UpperCAmelCase       :   List[str]					=	"""swin2sr"""

				UpperCAmelCase       :   List[Any]					=	{
				    """hidden_size""": """embed_dim""",
				    """num_attention_heads""": """num_heads""",
				    """num_hidden_layers""": """num_layers""",
				}



				def __init__(self       :   List[str]			,						_A       :   Tuple=64			,						_A       :   Optional[int]=1			,						_A       :   List[str]=3			,						_A       :   List[Any]=1_80			,						_A       :   List[str]=[6, 6, 6, 6, 6, 6]			,						_A       :   Optional[int]=[6, 6, 6, 6, 6, 6]			,						_A       :   List[str]=8			,						_A       :   str=2.0			,						_A       :   Tuple=True			,						_A       :   Union[str, Any]=0.0			,						_A       :   Tuple=0.0			,						_A       :   List[str]=0.1			,						_A       :   Tuple="gelu"			,						_A       :   Union[str, Any]=False			,						_A       :   Optional[Any]=0.02			,						_A       :   Tuple=1E-5			,						_A       :   Optional[Any]=2			,						_A       :   Dict=1.0			,						_A       :   List[Any]="1conv"			,						_A       :   Dict="pixelshuffle"			,						**_A       :   Optional[Any]			,						)					->			List[Any]:
					super().__init__(**__A)

					__snake_case    :							Dict   	=				image_size
					__snake_case    :							Tuple   	=				patch_size
					__snake_case    :							Tuple   	=				num_channels
					__snake_case    :							List[Any]   	=				embed_dim
					__snake_case    :							str   	=				depths
					__snake_case    :							str   	=				len(__A)
					__snake_case    :							str   	=				num_heads
					__snake_case    :							Tuple   	=				window_size
					__snake_case    :							Optional[int]   	=				mlp_ratio
					__snake_case    :							List[Any]   	=				qkv_bias
					__snake_case    :							Dict   	=				hidden_dropout_prob
					__snake_case    :							Optional[Any]   	=				attention_probs_dropout_prob
					__snake_case    :							str   	=				drop_path_rate
					__snake_case    :							int   	=				hidden_act
					__snake_case    :							List[str]   	=				use_absolute_embeddings
					__snake_case    :							str   	=				layer_norm_eps
					__snake_case    :							Any   	=				initializer_range
					__snake_case    :							str   	=				upscale
					__snake_case    :							Tuple   	=				img_range
					__snake_case    :							List[str]   	=				resi_connection
					__snake_case    :							List[Any]   	=				upsampler






"""simple docstring"""







from typing import TYPE_CHECKING

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


_a  :  Optional[Any]=				{
    "configuration_wav2vec2": ["WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP", "Wav2Vec2Config"],
    "feature_extraction_wav2vec2": ["Wav2Vec2FeatureExtractor"],
    "processing_wav2vec2": ["Wav2Vec2Processor"],
    "tokenization_wav2vec2": ["Wav2Vec2CTCTokenizer", "Wav2Vec2Tokenizer"],
}


try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_a  :  Optional[Any]=				[
	    "WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "Wav2Vec2ForAudioFrameClassification",
	    "Wav2Vec2ForCTC",
	    "Wav2Vec2ForMaskedLM",
	    "Wav2Vec2ForPreTraining",
	    "Wav2Vec2ForSequenceClassification",
	    "Wav2Vec2ForXVector",
	    "Wav2Vec2Model",
	    "Wav2Vec2PreTrainedModel",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_a  :  List[str]=				[
	    "TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "TFWav2Vec2ForCTC",
	    "TFWav2Vec2Model",
	    "TFWav2Vec2PreTrainedModel",
	    "TFWav2Vec2ForSequenceClassification",
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_a  :  List[Any]=				[
	    "FlaxWav2Vec2ForCTC",
	    "FlaxWav2Vec2ForPreTraining",
	    "FlaxWav2Vec2Model",
	    "FlaxWav2Vec2PreTrainedModel",
	]


if TYPE_CHECKING:
	from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
	from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
	from .processing_wavaveca import WavaVecaProcessor
	from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_wavaveca import (
		    WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
		    WavaVecaForAudioFrameClassification,
		    WavaVecaForCTC,
		    WavaVecaForMaskedLM,
		    WavaVecaForPreTraining,
		    WavaVecaForSequenceClassification,
		    WavaVecaForXVector,
		    WavaVecaModel,
		    WavaVecaPreTrainedModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_wavaveca import (
		    TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFWavaVecaForCTC,
		    TFWavaVecaForSequenceClassification,
		    TFWavaVecaModel,
		    TFWavaVecaPreTrainedModel,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_wavaveca import (
		    FlaxWavaVecaForCTC,
		    FlaxWavaVecaForPreTraining,
		    FlaxWavaVecaModel,
		    FlaxWavaVecaPreTrainedModel,
		)


else:
	import sys

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





