
from typing import TYPE_CHECKING

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


_A						      =				{
    "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						      =				[
       "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						      =				[
       "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						      =				[
       "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						      =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_A						      =				logging.get_logger(__name__)

_A						      =				{
    "sail/poolformer_s12": "https://huggingface.co/sail/poolformer_s12/resolve/main/config.json",
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
}







class   lowerCamelCase	(						A_						):
     UpperCAmelCase__       :							Any     =	"poolformer"





     def __init__(self   :					Optional[int]       ,					_A   :					Optional[Any]=3       ,					_A   :					Optional[int]=1_6       ,					_A   :					Dict=1_6       ,					_A   :					Tuple=3       ,					_A   :					Tuple=4.0       ,					_A   :					int=[2, 2, 6, 2]       ,					_A   :					Dict=[6_4, 1_2_8, 3_2_0, 5_1_2]       ,					_A   :					int=[7, 3, 3, 3]       ,					_A   :					List[str]=[4, 2, 2, 2]       ,					_A   :					str=[2, 1, 1, 1]       ,					_A   :					List[Any]=4       ,					_A   :					Any=0.0       ,					_A   :					Optional[Any]="gelu"       ,					_A   :					Optional[Any]=True       ,					_A   :					List[str]=1E-5       ,					_A   :					List[str]=0.02       ,					**_A   :					str       ,					)		->		Tuple:
         snake_case				  =      num_channels
         snake_case				  =      patch_size
         snake_case				  =      stride
         snake_case				  =      padding
         snake_case				  =      pool_size
         snake_case				  =      hidden_sizes
         snake_case				  =      mlp_ratio
         snake_case				  =      depths
         snake_case				  =      patch_sizes
         snake_case				  =      strides
         snake_case				  =      num_encoder_blocks
         snake_case				  =      drop_path_rate
         snake_case				  =      hidden_act
         snake_case				  =      use_layer_scale
         snake_case				  =      layer_scale_init_value
         snake_case				  =      initializer_range
         super().__init__(**_A     )







class   lowerCamelCase	(						A_						):
     UpperCAmelCase__       :							Tuple     =	version.parse("1.11"						)





     @property
     def 	UpperCAmelCase(self   :					int     )		->		Mapping[str, Mapping[int, str]]:
         return OrderedDict(
             [
                 ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
             ]     )





     @property
     def 	UpperCAmelCase(self   :					int     )		->		float:
         return 2E-3

