





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


_snake_case    :       str		       =    logging.get_logger(__name__)

_snake_case    :       Any		       =    {
    'facebook/s2t-wav2vec2-large-en-de': (
        'https://huggingface.co/facebook/s2t-wav2vec2-large-en-de/resolve/main/config.json'
    ),
    # See all Speech2Text models at https://huggingface.co/models?filter=speech2text2
}



class 							_UpperCAmelCase       (       _UpperCamelCase       ):

  """simple docstring"""


  a_              =					"""speech_to_text_2"""
  a_              =					["""past_key_values"""]
  a_              =					{"""num_attention_heads""": """decoder_attention_heads""", """hidden_size""": """d_model"""}






  def __init__(							self					:						Tuple   ,    lowerCAmelCase_					:						str=1_0_0_0_0   ,    lowerCAmelCase_					:						Optional[int]=6   ,    lowerCAmelCase_					:						Union[str, Any]=2_0_4_8   ,    lowerCAmelCase_					:						int=4   ,    lowerCAmelCase_					:						Optional[int]=0.0   ,    lowerCAmelCase_					:						Tuple=True   ,    lowerCAmelCase_					:						Union[str, Any]="relu"   ,    lowerCAmelCase_					:						int=2_5_6   ,    lowerCAmelCase_					:						Dict=0.1   ,    lowerCAmelCase_					:						Any=0.0   ,    lowerCAmelCase_					:						Any=0.0   ,    lowerCAmelCase_					:						Dict=0.02   ,    lowerCAmelCase_					:						Optional[Any]=2   ,    lowerCAmelCase_					:						Union[str, Any]=True   ,    lowerCAmelCase_					:						Optional[Any]=1   ,    lowerCAmelCase_					:						Any=0   ,    lowerCAmelCase_					:						Any=2   ,    lowerCAmelCase_					:						str=1_0_2_4   ,    **lowerCAmelCase_					:						Optional[Any]   ,    )				->		Optional[Any]:
     __lowerCAmelCase				      =      vocab_size
     __lowerCAmelCase				      =      d_model
     __lowerCAmelCase				      =      decoder_ffn_dim
     __lowerCAmelCase				      =      decoder_layers
     __lowerCAmelCase				      =      decoder_attention_heads
     __lowerCAmelCase				      =      dropout
     __lowerCAmelCase				      =      attention_dropout
     __lowerCAmelCase				      =      activation_dropout
     __lowerCAmelCase				      =      activation_function
     __lowerCAmelCase				      =      init_std
     __lowerCAmelCase				      =      decoder_layerdrop
     __lowerCAmelCase				      =      use_cache
     __lowerCAmelCase				      =      decoder_layers
     __lowerCAmelCase				      =      scale_embedding  # scale factor will be sqrt(d_model) if True
     __lowerCAmelCase				      =      max_target_positions

     super().__init__(
         pad_token_id=lowerCAmelCase_   ,    bos_token_id=lowerCAmelCase_   ,    eos_token_id=lowerCAmelCase_   ,    decoder_start_token_id=lowerCAmelCase_   ,    **lowerCAmelCase_   ,    )





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


lowerCamelCase__							:						List[Any]							     =   logging.get_logger(__name__)

lowerCamelCase__							:						Optional[int]							     =   {
    """facebook/data2vec-vision-base-ft""": (
        """https://huggingface.co/facebook/data2vec-vision-base-ft/resolve/main/config.json"""
    ),
}
class 		__magic_name__						(snake_case_				):





     '''simple docstring'''



     __lowercase				:							Optional[int]	   =       'data2vec-vision'

     def __init__(					self:int     ,		_a:Tuple=7_68     ,		_a:int=12     ,		_a:Any=12     ,		_a:Optional[int]=30_72     ,		_a:Optional[int]="gelu"     ,		_a:Any=0.0     ,		_a:Any=0.0     ,		_a:List[str]=0.02     ,		_a:Dict=1e-12     ,		_a:Tuple=2_24     ,		_a:Any=16     ,		_a:str=3     ,		_a:str=False     ,		_a:Union[str, Any]=False     ,		_a:Optional[int]=False     ,		_a:Any=False     ,		_a:Dict=0.1     ,		_a:Dict=0.1     ,		_a:str=True     ,		_a:str=[3, 5, 7, 11]     ,		_a:List[str]=[1, 2, 3, 6]     ,		_a:List[str]=True     ,		_a:Any=0.4     ,		_a:str=2_56     ,		_a:Union[str, Any]=1     ,		_a:int=False     ,		_a:Optional[int]=2_55     ,		**_a:Dict     ,		):
       super().__init__(**_a   )

       snake_case__						= hidden_size
       snake_case__						= num_hidden_layers
       snake_case__						= num_attention_heads
       snake_case__						= intermediate_size
       snake_case__						= hidden_act
       snake_case__						= hidden_dropout_prob
       snake_case__						= attention_probs_dropout_prob
       snake_case__						= initializer_range
       snake_case__						= layer_norm_eps

       snake_case__						= image_size
       snake_case__						= patch_size
       snake_case__						= num_channels
       snake_case__						= use_mask_token
       snake_case__						= use_absolute_position_embeddings
       snake_case__						= use_relative_position_bias
       snake_case__						= use_shared_relative_position_bias
       snake_case__						= layer_scale_init_value
       snake_case__						= drop_path_rate
       snake_case__						= use_mean_pooling
       # decode head attributes (semantic segmentation)
       snake_case__						= out_indices
       snake_case__						= pool_scales
       # auxiliary head attributes (semantic segmentation)
       snake_case__						= use_auxiliary_head
       snake_case__						= auxiliary_loss_weight
       snake_case__						= auxiliary_channels
       snake_case__						= auxiliary_num_convs
       snake_case__						= auxiliary_concat_input
       snake_case__						= semantic_loss_ignore_index




class 		__magic_name__						(snake_case_				):





     '''simple docstring'''



     __lowercase				:							Any	   =       version.parse('1.11'				)

     @property
     def 	SCREAMING_SNAKE_CASE__						(					self:List[str]   ):
       return OrderedDict(
           [
               ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
           ]   )







     @property
     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       return 1e-4

