


import warnings
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


snake_case							:       Optional[int]										=	logging.get_logger(__name__)

snake_case							:       Optional[Any]										=	{
    '''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/config.json''',
    # See all BART models at https://huggingface.co/models?filter=bart
}







class 						_snake_case    ( _snake_case				):
 SCREAMING_SNAKE_CASE__ =			'bart'
 SCREAMING_SNAKE_CASE__ =			['past_key_values']
 SCREAMING_SNAKE_CASE__ =			{'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}




 def __init__(						self   ,    _lowerCamelCase=5_0265   ,    _lowerCamelCase=1024   ,    _lowerCamelCase=12   ,    _lowerCamelCase=4096   ,    _lowerCamelCase=16   ,    _lowerCamelCase=12   ,    _lowerCamelCase=4096   ,    _lowerCamelCase=16   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase="gelu"   ,    _lowerCamelCase=1024   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=0.02   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=False   ,    _lowerCamelCase=True   ,    _lowerCamelCase=3   ,    _lowerCamelCase=1   ,    _lowerCamelCase=0   ,    _lowerCamelCase=2   ,    _lowerCamelCase=True   ,    _lowerCamelCase=2   ,    _lowerCamelCase=2   ,    **_lowerCamelCase   ,    ):
       a		:Union[str, Any]									=			vocab_size
       a		:Union[str, Any]									=			max_position_embeddings
       a		:int									=			d_model
       a		:Any									=			encoder_ffn_dim
       a		:Optional[int]									=			encoder_layers
       a		:Dict									=			encoder_attention_heads
       a		:Optional[int]									=			decoder_ffn_dim
       a		:Dict									=			decoder_layers
       a		:Tuple									=			decoder_attention_heads
       a		:Dict									=			dropout
       a		:Optional[int]									=			attention_dropout
       a		:Optional[int]									=			activation_dropout
       a		:str									=			activation_function
       a		:str									=			init_std
       a		:Optional[Any]									=			encoder_layerdrop
       a		:List[str]									=			decoder_layerdrop
       a		:Any									=			classifier_dropout
       a		:Dict									=			use_cache
       a		:int									=			encoder_layers
       a		:int									=			scale_embedding  # scale factor will be sqrt(d_model) if True

       super().__init__(
           num_labels=_lowerCamelCase   ,    pad_token_id=_lowerCamelCase   ,    bos_token_id=_lowerCamelCase   ,    eos_token_id=_lowerCamelCase   ,    is_encoder_decoder=_lowerCamelCase   ,    decoder_start_token_id=_lowerCamelCase   ,    forced_eos_token_id=_lowerCamelCase   ,    **_lowerCamelCase   ,    )

       # ensure backward compatibility for BART CNN models
       if self.forced_bos_token_id is None and kwargs.get('''force_bos_token_to_be_generated'''   ,    _lowerCamelCase       ):
             a		:int									=			self.bos_token_id
             warnings.warn(
                 F'''Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. '''
                 '''The config can simply be saved and uploaded again to be fixed.'''       )







class 						_snake_case    ( _snake_case				):




 @property
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       if self.task in ["default", "seq2seq-lm"]:
             a		:Any									=			OrderedDict(
                 [
                     ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                     ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                 ]       )

             if self.use_past:
                   a		:Optional[Any]									=			{0: '''batch'''}
                   a		:Union[str, Any]									=			{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
             else:
                   a		:Optional[int]									=			{0: '''batch''', 1: '''decoder_sequence'''}
                   a		:Any									=			{0: '''batch''', 1: '''decoder_sequence'''}

             if self.use_past:
                   self.fill_with_past_key_values_(_lowerCamelCase   ,    direction='''inputs'''       )
       elif self.task == "causal-lm":
             # TODO: figure this case out.
             a		:Tuple									=			OrderedDict(
                 [
                     ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                     ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                 ]       )
             if self.use_past:
                   a				,							a		:List[Any]									=			self.num_layers
                   for i in range(_lowerCamelCase       ):
                         a		:List[str]									=			{0: '''batch''', 2: '''past_sequence + sequence'''}
                         a		:int									=			{0: '''batch''', 2: '''past_sequence + sequence'''}
       else:
             a		:List[str]									=			OrderedDict(
                 [
                     ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
                     ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
                     ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
                     ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
                 ]       )

       return common_inputs




 @property
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       if self.task in ["default", "seq2seq-lm"]:
             a		:int									=			super().outputs
       else:
             a		:Optional[int]									=			super(_lowerCamelCase   ,    self       ).outputs
             if self.use_past:
                   a				,							a		:Union[str, Any]									=			self.num_layers
                   for i in range(_lowerCamelCase       ):
                         a		:List[str]									=			{0: '''batch''', 2: '''past_sequence + sequence'''}
                         a		:str									=			{0: '''batch''', 2: '''past_sequence + sequence'''}
       return common_outputs




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase = -1   ,    _lowerCamelCase = -1   ,    _lowerCamelCase = False   ,    _lowerCamelCase = None   ,    ):
       a		:Optional[Any]									=			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       )

       # Generate decoder inputs
       a		:Any									=			seq_length if not self.use_past else 1
       a		:int									=			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       )
       a		:List[str]									=			{F'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
       a		:Optional[int]									=			dict(**_lowerCamelCase   ,    **_lowerCamelCase       )

       if self.use_past:
             if not is_torch_available():
                   raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''       )
             else:
                   import torch
             a				,							a		:int									=			common_inputs['''input_ids'''].shape
             a		:Optional[int]									=			common_inputs['''decoder_input_ids'''].shape[1]
             a				,							a		:Tuple									=			self.num_attention_heads
             a		:Any									=			(
                 batch,
                 num_encoder_attention_heads,
                 encoder_seq_length,
                 self._config.hidden_size // num_encoder_attention_heads,
             )
             a		:Union[str, Any]									=			decoder_seq_length + 3
             a		:int									=			(
                 batch,
                 num_decoder_attention_heads,
                 decoder_past_length,
                 self._config.hidden_size // num_decoder_attention_heads,
             )

             a		:int									=			torch.cat(
                 [common_inputs['''decoder_attention_mask'''], torch.ones(_lowerCamelCase   ,    _lowerCamelCase       )]   ,    dim=1       )

             a		:List[Any]									=			[]
             # If the number of encoder and decoder layers are present in the model configuration, both are considered
             a				,							a		:Optional[Any]									=			self.num_layers
             a		:Optional[Any]									=			min(_lowerCamelCase   ,    _lowerCamelCase       )
             a		:List[Any]									=			max(_lowerCamelCase   ,    _lowerCamelCase       ) - min_num_layers
             a		:int									=			'''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''

             for _ in range(_lowerCamelCase       ):
                   common_inputs["past_key_values"].append(
                       (
                           torch.zeros(_lowerCamelCase       ),
                           torch.zeros(_lowerCamelCase       ),
                           torch.zeros(_lowerCamelCase       ),
                           torch.zeros(_lowerCamelCase       ),
                       )       )
             # TODO: test this.
             a		:Union[str, Any]									=			encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
             for _ in range(_lowerCamelCase   ,    _lowerCamelCase       ):
                   common_inputs["past_key_values"].append((torch.zeros(_lowerCamelCase       ), torch.zeros(_lowerCamelCase       ))       )
       return common_inputs




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase = -1   ,    _lowerCamelCase = -1   ,    _lowerCamelCase = False   ,    _lowerCamelCase = None   ,    ):
       a		:Tuple									=			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       )

       if self.use_past:
             if not is_torch_available():
                   raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''       )
             else:
                   import torch
             a				,							a		:List[Any]									=			common_inputs['''input_ids'''].shape
             # Not using the same length for past_key_values
             a		:Union[str, Any]									=			seqlen + 2
             a				,							a		:Dict									=			self.num_layers
             a				,							a		:int									=			self.num_attention_heads
             a		:Optional[int]									=			(
                 batch,
                 num_encoder_attention_heads,
                 past_key_values_length,
                 self._config.hidden_size // num_encoder_attention_heads,
             )

             a		:List[str]									=			common_inputs['''attention_mask'''].dtype
             a		:List[Any]									=			torch.cat(
                 [common_inputs['''attention_mask'''], torch.ones(_lowerCamelCase   ,    _lowerCamelCase   ,    dtype=_lowerCamelCase       )]   ,    dim=1       )
             a		:Optional[Any]									=			[
                 (torch.zeros(_lowerCamelCase       ), torch.zeros(_lowerCamelCase       )) for _ in range(_lowerCamelCase       )
             ]
       return common_inputs




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase = -1   ,    _lowerCamelCase = -1   ,    _lowerCamelCase = False   ,    _lowerCamelCase = None   ,    ):
       # Copied from OnnxConfig.generate_dummy_inputs
       # Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
       # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
       a		:Optional[Any]									=			compute_effective_axis_dimension(
           _lowerCamelCase   ,    fixed_dimension=OnnxConfig.default_fixed_batch   ,    num_token_to_add=0       )

       # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
       a		:List[Any]									=			tokenizer.num_special_tokens_to_add(_lowerCamelCase       )
       a		:List[Any]									=			compute_effective_axis_dimension(
           _lowerCamelCase   ,    fixed_dimension=OnnxConfig.default_fixed_sequence   ,    num_token_to_add=_lowerCamelCase       )

       # Generate dummy inputs according to compute batch and sequence
       a		:Optional[Any]									=			[''' '''.join([tokenizer.unk_token]       ) * seq_length] * batch_size
       a		:int									=			dict(tokenizer(_lowerCamelCase   ,    return_tensors=_lowerCamelCase       )       )
       return common_inputs




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase = -1   ,    _lowerCamelCase = -1   ,    _lowerCamelCase = False   ,    _lowerCamelCase = None   ,    ):
       if self.task in ["default", "seq2seq-lm"]:
             a		:Optional[int]									=			self._generate_dummy_inputs_for_default_and_seqaseq_lm(
                 _lowerCamelCase   ,    batch_size=_lowerCamelCase   ,    seq_length=_lowerCamelCase   ,    is_pair=_lowerCamelCase   ,    framework=_lowerCamelCase       )

       elif self.task == "causal-lm":
             a		:Dict									=			self._generate_dummy_inputs_for_causal_lm(
                 _lowerCamelCase   ,    batch_size=_lowerCamelCase   ,    seq_length=_lowerCamelCase   ,    is_pair=_lowerCamelCase   ,    framework=_lowerCamelCase       )
       else:
             a		:str									=			self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
                 _lowerCamelCase   ,    batch_size=_lowerCamelCase   ,    seq_length=_lowerCamelCase   ,    is_pair=_lowerCamelCase   ,    framework=_lowerCamelCase       )

       return common_inputs




 def 			SCREAMING_SNAKE_CASE__							(						self   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       ):
       if self.task in ["default", "seq2seq-lm"]:
             a		:Any									=			super()._flatten_past_key_values_(_lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       )
       else:
             a		:Tuple									=			super(_lowerCamelCase   ,    self       )._flatten_past_key_values_(
                 _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase   ,    _lowerCamelCase       )









import functools
import operator

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


snake_case							:       Optional[int]										=	logging.get_logger(__name__)

snake_case							:       Optional[int]										=	{
    '''microsoft/unispeech-large-1500h-cv''': (
        '''https://huggingface.co/microsoft/unispeech-large-1500h-cv/resolve/main/config.json'''
    ),
    # See all UniSpeech models at https://huggingface.co/models?filter=unispeech
}







class 						_snake_case    ( _snake_case				):
 SCREAMING_SNAKE_CASE__ =			'unispeech'




 def __init__(						self   ,    _lowerCamelCase=32   ,    _lowerCamelCase=768   ,    _lowerCamelCase=12   ,    _lowerCamelCase=12   ,    _lowerCamelCase=3072   ,    _lowerCamelCase="gelu"   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=0.02   ,    _lowerCamelCase=1e-5   ,    _lowerCamelCase="group"   ,    _lowerCamelCase="gelu"   ,    _lowerCamelCase=(512, 512, 512, 512, 512, 512, 512)   ,    _lowerCamelCase=(5, 2, 2, 2, 2, 2, 2)   ,    _lowerCamelCase=(10, 3, 3, 3, 3, 2, 2)   ,    _lowerCamelCase=False   ,    _lowerCamelCase=128   ,    _lowerCamelCase=16   ,    _lowerCamelCase=False   ,    _lowerCamelCase=True   ,    _lowerCamelCase=0.05   ,    _lowerCamelCase=10   ,    _lowerCamelCase=2   ,    _lowerCamelCase=0.0   ,    _lowerCamelCase=10   ,    _lowerCamelCase=0   ,    _lowerCamelCase=320   ,    _lowerCamelCase=2   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase=100   ,    _lowerCamelCase=256   ,    _lowerCamelCase=256   ,    _lowerCamelCase=0.1   ,    _lowerCamelCase="mean"   ,    _lowerCamelCase=False   ,    _lowerCamelCase=False   ,    _lowerCamelCase=256   ,    _lowerCamelCase=80   ,    _lowerCamelCase=0   ,    _lowerCamelCase=1   ,    _lowerCamelCase=2   ,    _lowerCamelCase=0.5   ,    **_lowerCamelCase   ,    ):
       super().__init__(**_lowerCamelCase   ,    pad_token_id=_lowerCamelCase   ,    bos_token_id=_lowerCamelCase   ,    eos_token_id=_lowerCamelCase       )
       a		:Any									=			hidden_size
       a		:str									=			feat_extract_norm
       a		:List[Any]									=			feat_extract_activation
       a		:Tuple									=			list(_lowerCamelCase       )
       a		:Any									=			list(_lowerCamelCase       )
       a		:List[Any]									=			list(_lowerCamelCase       )
       a		:Union[str, Any]									=			conv_bias
       a		:str									=			num_conv_pos_embeddings
       a		:str									=			num_conv_pos_embedding_groups
       a		:Tuple									=			len(self.conv_dim       )
       a		:int									=			num_hidden_layers
       a		:Any									=			intermediate_size
       a		:Optional[Any]									=			hidden_act
       a		:Tuple									=			num_attention_heads
       a		:Any									=			hidden_dropout
       a		:Any									=			attention_dropout
       a		:Optional[Any]									=			activation_dropout
       a		:Optional[Any]									=			feat_proj_dropout
       a		:Any									=			final_dropout
       a		:int									=			layerdrop
       a		:int									=			layer_norm_eps
       a		:Dict									=			initializer_range
       a		:Dict									=			num_ctc_classes
       a		:Optional[Any]									=			vocab_size
       a		:str									=			do_stable_layer_norm
       a		:Tuple									=			use_weighted_layer_sum
       a		:Any									=			classifier_proj_size

       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
       a		:List[Any]									=			apply_spec_augment
       a		:Any									=			mask_time_prob
       a		:Union[str, Any]									=			mask_time_length
       a		:str									=			mask_time_min_masks
       a		:Tuple									=			mask_feature_prob
       a		:Dict									=			mask_feature_length
       a		:int									=			mask_feature_min_masks

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

       # ctc loss
       a		:List[Any]									=			ctc_loss_reduction
       a		:Union[str, Any]									=			ctc_zero_infinity

       # pretraining loss
       a		:int									=			replace_prob




 @property
 def 			SCREAMING_SNAKE_CASE__							(						self       ):
       return functools.reduce(operator.mul   ,    self.conv_stride   ,    1       )





