




import functools
import operator

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


UpperCAmelCase_		:				Tuple									=     logging.get_logger(__name__)

UpperCAmelCase_		:				List[Any]									=     {
    "microsoft/unispeech-sat-base-100h-libri-ft": (
        "https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft/resolve/main/config.json"
    ),
    # See all UniSpeechSat models at https://huggingface.co/models?filter=unispeech_sat
}




class 		__A      (			UpperCamelCase__			):
						UpperCamelCase     						=					"""unispeech-sat"""

						def __init__(		self   :Tuple    , __snake_case   :Union[str, Any]=32    , __snake_case   :Dict=7_68    , __snake_case   :List[Any]=12    , __snake_case   :Any=12    , __snake_case   :List[str]=30_72    , __snake_case   :Union[str, Any]="gelu"    , __snake_case   :List[str]=0.1    , __snake_case   :str=0.1    , __snake_case   :List[str]=0.1    , __snake_case   :Optional[Any]=0.0    , __snake_case   :List[Any]=0.0    , __snake_case   :str=0.1    , __snake_case   :Union[str, Any]=0.1    , __snake_case   :Tuple=0.02    , __snake_case   :List[Any]=1E-5    , __snake_case   :List[str]="group"    , __snake_case   :int="gelu"    , __snake_case   :Union[str, Any]=(5_12, 5_12, 5_12, 5_12, 5_12, 5_12, 5_12)    , __snake_case   :str=(5, 2, 2, 2, 2, 2, 2)    , __snake_case   :Any=(10, 3, 3, 3, 3, 2, 2)    , __snake_case   :List[Any]=False    , __snake_case   :Optional[int]=1_28    , __snake_case   :Tuple=16    , __snake_case   :Union[str, Any]=False    , __snake_case   :List[str]=True    , __snake_case   :Optional[int]=0.05    , __snake_case   :Tuple=10    , __snake_case   :Tuple=2    , __snake_case   :Dict=0.0    , __snake_case   :Optional[Any]=10    , __snake_case   :Dict=0    , __snake_case   :Tuple=3_20    , __snake_case   :int=2    , __snake_case   :List[str]=0.1    , __snake_case   :Union[str, Any]=1_00    , __snake_case   :Tuple=2_56    , __snake_case   :Optional[Any]=2_56    , __snake_case   :str=0.1    , __snake_case   :Optional[Any]="mean"    , __snake_case   :List[Any]=False    , __snake_case   :Union[str, Any]=False    , __snake_case   :Optional[Any]=2_56    , __snake_case   :Union[str, Any]=(5_12, 5_12, 5_12, 5_12, 15_00)    , __snake_case   :Dict=(5, 3, 3, 1, 1)    , __snake_case   :Tuple=(1, 2, 3, 1, 1)    , __snake_case   :Tuple=5_12    , __snake_case   :Dict=0    , __snake_case   :List[Any]=1    , __snake_case   :List[Any]=2    , __snake_case   :Union[str, Any]=5_04    , **__snake_case   :int    , ):
										'''simple docstring'''

										super().__init__(**__snake_case    , pad_token_id=__snake_case    , bos_token_id=__snake_case    , eos_token_id=__snake_case )
										__magic_name__	:	List[Any]								=hidden_size
										__magic_name__	:	Optional[int]								=feat_extract_norm
										__magic_name__	:	Dict								=feat_extract_activation
										__magic_name__	:	Tuple								=list(__snake_case )
										__magic_name__	:	Dict								=list(__snake_case )
										__magic_name__	:	List[str]								=list(__snake_case )
										__magic_name__	:	Any								=conv_bias
										__magic_name__	:	List[Any]								=num_conv_pos_embeddings
										__magic_name__	:	Any								=num_conv_pos_embedding_groups
										__magic_name__	:	Dict								=len(self.conv_dim )
										__magic_name__	:	Optional[Any]								=num_hidden_layers
										__magic_name__	:	int								=intermediate_size
										__magic_name__	:	List[Any]								=hidden_act
										__magic_name__	:	Tuple								=num_attention_heads
										__magic_name__	:	Union[str, Any]								=hidden_dropout
										__magic_name__	:	Optional[Any]								=attention_dropout
										__magic_name__	:	Optional[Any]								=activation_dropout
										__magic_name__	:	Optional[int]								=feat_proj_dropout
										__magic_name__	:	Dict								=final_dropout
										__magic_name__	:	Optional[int]								=layerdrop
										__magic_name__	:	Dict								=layer_norm_eps
										__magic_name__	:	Optional[Any]								=initializer_range
										__magic_name__	:	int								=vocab_size
										__magic_name__	:	Tuple								=num_clusters
										__magic_name__	:	Dict								=do_stable_layer_norm
										__magic_name__	:	Optional[Any]								=use_weighted_layer_sum

										if (
										    (len(self.conv_stride ) != self.num_feat_extract_layers)
										    or (len(self.conv_kernel ) != self.num_feat_extract_layers)
										    or (len(self.conv_dim ) != self.num_feat_extract_layers)
										):
														raise ValueError(
														    """Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="""
														    """ `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="""
														    f" {len(self.conv_dim )}`, `len(config.conv_stride) = {len(self.conv_stride )}`,"
														    f" `len(config.conv_kernel) = {len(self.conv_kernel )}`." )

										# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
										__magic_name__	:	Union[str, Any]								=apply_spec_augment
										__magic_name__	:	Tuple								=mask_time_prob
										__magic_name__	:	str								=mask_time_length
										__magic_name__	:	Optional[Any]								=mask_time_min_masks
										__magic_name__	:	Optional[Any]								=mask_feature_prob
										__magic_name__	:	List[str]								=mask_feature_length
										__magic_name__	:	int								=mask_feature_min_masks

										# parameters for pretraining with codevector quantized representations
										__magic_name__	:	Optional[int]								=num_codevectors_per_group
										__magic_name__	:	List[str]								=num_codevector_groups
										__magic_name__	:	Optional[int]								=contrastive_logits_temperature
										__magic_name__	:	Tuple								=feat_quantizer_dropout
										__magic_name__	:	Any								=num_negatives
										__magic_name__	:	Optional[int]								=codevector_dim
										__magic_name__	:	List[Any]								=proj_codevector_dim
										__magic_name__	:	int								=diversity_loss_weight

										# ctc loss
										__magic_name__	:	List[Any]								=ctc_loss_reduction
										__magic_name__	:	str								=ctc_zero_infinity

										# SequenceClassification-specific parameter. Feel free to ignore for other classes.
										__magic_name__	:	str								=classifier_proj_size

										# XVector-specific parameters. Feel free to ignore for other classes.
										__magic_name__	:	Union[str, Any]								=list(__snake_case )
										__magic_name__	:	Union[str, Any]								=list(__snake_case )
										__magic_name__	:	Any								=list(__snake_case )
										__magic_name__	:	Dict								=xvector_output_dim


						@property
						def     A__						(		self   :Any ):
										'''simple docstring'''

										return functools.reduce(operator.mul    , self.conv_stride    , 1 )










from typing import Mapping

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


UpperCAmelCase_		:				str									=     logging.get_logger(__name__)

UpperCAmelCase_		:				Tuple									=     {
    "t5-small": "https://huggingface.co/t5-small/resolve/main/config.json",
    "t5-base": "https://huggingface.co/t5-base/resolve/main/config.json",
    "t5-large": "https://huggingface.co/t5-large/resolve/main/config.json",
    "t5-3b": "https://huggingface.co/t5-3b/resolve/main/config.json",
    "t5-11b": "https://huggingface.co/t5-11b/resolve/main/config.json",
}




class 		__A      (			UpperCamelCase__			):
						UpperCamelCase     						=					"""t5"""
						UpperCamelCase     						=					["""past_key_values"""]
						UpperCamelCase     						=					{"""hidden_size""": """d_model""", """num_attention_heads""": """num_heads""", """num_hidden_layers""": """num_layers"""}

						def __init__(		self   :Optional[Any]    , __snake_case   :Optional[Any]=3_21_28    , __snake_case   :Optional[int]=5_12    , __snake_case   :str=64    , __snake_case   :int=20_48    , __snake_case   :Union[str, Any]=6    , __snake_case   :Union[str, Any]=None    , __snake_case   :Union[str, Any]=8    , __snake_case   :List[str]=32    , __snake_case   :Dict=1_28    , __snake_case   :List[Any]=0.1    , __snake_case   :int=1E-6    , __snake_case   :List[str]=1.0    , __snake_case   :Optional[int]="relu"    , __snake_case   :List[str]=True    , __snake_case   :Union[str, Any]=True    , __snake_case   :Union[str, Any]=0    , __snake_case   :str=1    , **__snake_case   :int    , ):
										'''simple docstring'''

										__magic_name__	:	str								=vocab_size
										__magic_name__	:	str								=d_model
										__magic_name__	:	Optional[Any]								=d_kv
										__magic_name__	:	int								=d_ff
										__magic_name__	:	Union[str, Any]								=num_layers
										__magic_name__	:	Tuple								=(
										    num_decoder_layers if num_decoder_layers is not None else self.num_layers
										)  # default = symmetry
										__magic_name__	:	List[str]								=num_heads
										__magic_name__	:	Optional[Any]								=relative_attention_num_buckets
										__magic_name__	:	Union[str, Any]								=relative_attention_max_distance
										__magic_name__	:	Dict								=dropout_rate
										__magic_name__	:	Dict								=layer_norm_epsilon
										__magic_name__	:	List[str]								=initializer_factor
										__magic_name__	:	Any								=feed_forward_proj
										__magic_name__	:	Optional[int]								=use_cache

										__magic_name__	:	Tuple								=self.feed_forward_proj.split("""-""" )
										__magic_name__	:	int								=act_info[-1]
										__magic_name__	:	int								=act_info[0] == """gated"""

										if len(__snake_case ) > 1 and act_info[0] != "gated" or len(__snake_case ) > 2:
														raise ValueError(
														    f"`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer."
														    """Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. """
														    """'gated-gelu' or 'relu'""" )

										# for backwards compatibility
										if feed_forward_proj == "gated-gelu":
														__magic_name__	:	str								="""gelu_new"""

										super().__init__(
										    pad_token_id=__snake_case    , eos_token_id=__snake_case    , is_encoder_decoder=__snake_case    , **__snake_case    , )




class 		__A      (			UpperCamelCase__			):

						@property
						def     A__						(		self   :List[Any] ):
										'''simple docstring'''

										__magic_name__	:	int								={
										    """input_ids""": {0: """batch""", 1: """encoder_sequence"""},
										    """attention_mask""": {0: """batch""", 1: """encoder_sequence"""},
										}
										if self.use_past:
														__magic_name__	:	List[str]								="""past_encoder_sequence + sequence"""
														__magic_name__	:	List[Any]								={0: """batch"""}
														__magic_name__	:	Union[str, Any]								={0: """batch""", 1: """past_decoder_sequence + sequence"""}
										else:
														__magic_name__	:	int								={0: """batch""", 1: """decoder_sequence"""}
														__magic_name__	:	Tuple								={0: """batch""", 1: """decoder_sequence"""}

										if self.use_past:
														self.fill_with_past_key_values_(__snake_case    , direction="""inputs""" )

										return common_inputs


						@property
						def     A__						(		self   :Union[str, Any] ):
										'''simple docstring'''

										return 13




