






"""simple docstring"""





import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_squeezebert import SqueezeBertTokenizer


__lowerCamelCase							=  logging.get_logger(__name__)

__lowerCamelCase							=  {'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

__lowerCamelCase							=  {
    'vocab_file': {
        'squeezebert/squeezebert-uncased': (
            'https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/vocab.txt'
        ),
        'squeezebert/squeezebert-mnli': 'https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/vocab.txt',
        'squeezebert/squeezebert-mnli-headless': (
            'https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'squeezebert/squeezebert-uncased': (
            'https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/tokenizer.json'
        ),
        'squeezebert/squeezebert-mnli': (
            'https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/tokenizer.json'
        ),
        'squeezebert/squeezebert-mnli-headless': (
            'https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/tokenizer.json'
        ),
    },
}

__lowerCamelCase							=  {
    'squeezebert/squeezebert-uncased': 5_12,
    'squeezebert/squeezebert-mnli': 5_12,
    'squeezebert/squeezebert-mnli-headless': 5_12,
}


__lowerCamelCase							=  {
    'squeezebert/squeezebert-uncased': {'do_lower_case': True},
    'squeezebert/squeezebert-mnli': {'do_lower_case': True},
    'squeezebert/squeezebert-mnli-headless': {'do_lower_case': True},
}



class       __A		(   SCREAMING_SNAKE_CASE_			):
					UpperCAmelCase__								=				VOCAB_FILES_NAMES
					UpperCAmelCase__								=				PRETRAINED_VOCAB_FILES_MAP
					UpperCAmelCase__								=				PRETRAINED_INIT_CONFIGURATION
					UpperCAmelCase__								=				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					UpperCAmelCase__								=				SqueezeBertTokenizer

					def __init__(			self  :      Tuple     ,		__snake_case  :      str=None     ,		__snake_case  :      Optional[Any]=None     ,		__snake_case  :      str=True     ,		__snake_case  :      str="[UNK]"     ,		__snake_case  :      int="[SEP]"     ,		__snake_case  :      int="[PAD]"     ,		__snake_case  :      Any="[CLS]"     ,		__snake_case  :      List[Any]="[MASK]"     ,		__snake_case  :      Union[str, Any]=True     ,		__snake_case  :      Dict=None     ,		**__snake_case  :      str     ,		)			->							List[Any]:
											super().__init__(
											    __snake_case     ,		tokenizer_file=__snake_case     ,		do_lower_case=__snake_case     ,		unk_token=__snake_case     ,		sep_token=__snake_case     ,		pad_token=__snake_case     ,		cls_token=__snake_case     ,		mask_token=__snake_case     ,		tokenize_chinese_chars=__snake_case     ,		strip_accents=__snake_case     ,		**__snake_case     ,		)

											__magic_name__:	List[Any]							=       json.loads(self.backend_tokenizer.normalizer.__getstate__()					)
											if (
											    normalizer_state.get("""lowercase"""     ,		__snake_case					) != do_lower_case
											    or normalizer_state.get("""strip_accents"""     ,		__snake_case					) != strip_accents
											    or normalizer_state.get("""handle_chinese_chars"""     ,		__snake_case					) != tokenize_chinese_chars
											):
																	__magic_name__:	Dict							=       getattr(__snake_case     ,		normalizer_state.pop("""type"""					)					)
																	__magic_name__:	Optional[Any]							=       do_lower_case
																	__magic_name__:	Any							=       strip_accents
																	__magic_name__:	Any							=       tokenize_chinese_chars
																	__magic_name__:	Union[str, Any]							=       normalizer_class(**__snake_case					)

											__magic_name__:	Optional[Any]							=       do_lower_case

					def   lowerCamelCase__   (			self  :      Optional[Any]     ,		__snake_case  :      List[Any]     ,		__snake_case  :      int=None					)			->							Optional[int]:
											__magic_name__:	int							=       [self.cls_token_id] + token_ids_a + [self.sep_token_id]

											if token_ids_a:
																	output += token_ids_a + [self.sep_token_id]

											return output

					def   lowerCamelCase__   (			self  :      Any     ,		__snake_case  :      List[int]     ,		__snake_case  :      Optional[List[int]] = None					)			->							List[int]:
											__magic_name__:	Dict							=       [self.sep_token_id]
											__magic_name__:	List[str]							=       [self.cls_token_id]
											if token_ids_a is None:
																	return len(cls + token_ids_a + sep					) * [0]
											return len(cls + token_ids_a + sep					) * [0] + len(token_ids_a + sep					) * [1]






					def   lowerCamelCase__   (			self  :      Dict     ,		__snake_case  :      str     ,		__snake_case  :      Optional[str] = None					)			->							Tuple[str]:
											__magic_name__:	Any							=       self._tokenizer.model.save(__snake_case     ,		name=__snake_case					)
											return tuple(__snake_case					)





'''simple docstring'''





import functools
import operator

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


SCREAMING_SNAKE_CASE     =       logging.get_logger(__name__)

SCREAMING_SNAKE_CASE     =       {
    """microsoft/wavlm-base""": """https://huggingface.co/microsoft/wavlm-base/resolve/main/config.json""",
    # See all WavLM models at https://huggingface.co/models?filter=wavlm
}






class 							UpperCAmelCase_							(    A				):

 '''simple docstring'''
 lowercase_					:    List[str]				=							"wavlm"







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



   '''simple docstring'''




   super().__init__(**snake_case__			,				pad_token_id=snake_case__			,				bos_token_id=snake_case__			,				eos_token_id=snake_case__ )
   UpperCAmelCase__      :					Union[str, Any]				       =							hidden_size
   UpperCAmelCase__      :					List[str]				       =							feat_extract_norm
   UpperCAmelCase__      :					int				       =							feat_extract_activation
   UpperCAmelCase__      :					Optional[int]				       =							list(snake_case__ )
   UpperCAmelCase__      :					Tuple				       =							list(snake_case__ )
   UpperCAmelCase__      :					Tuple				       =							list(snake_case__ )
   UpperCAmelCase__      :					Tuple				       =							conv_bias
   UpperCAmelCase__      :					List[Any]				       =							num_buckets
   UpperCAmelCase__      :					Union[str, Any]				       =							max_bucket_distance
   UpperCAmelCase__      :					Tuple				       =							num_conv_pos_embeddings
   UpperCAmelCase__      :					Union[str, Any]				       =							num_conv_pos_embedding_groups
   UpperCAmelCase__      :					Optional[Any]				       =							len(self.conv_dim )
   UpperCAmelCase__      :					Optional[int]				       =							num_hidden_layers
   UpperCAmelCase__      :					Tuple				       =							intermediate_size
   UpperCAmelCase__      :					List[str]				       =							hidden_act
   UpperCAmelCase__      :					List[str]				       =							num_attention_heads
   UpperCAmelCase__      :					Any				       =							hidden_dropout
   UpperCAmelCase__      :					List[Any]				       =							attention_dropout
   UpperCAmelCase__      :					Optional[int]				       =							activation_dropout
   UpperCAmelCase__      :					Optional[Any]				       =							feat_proj_dropout
   UpperCAmelCase__      :					List[str]				       =							final_dropout
   UpperCAmelCase__      :					int				       =							layerdrop
   UpperCAmelCase__      :					int				       =							layer_norm_eps
   UpperCAmelCase__      :					Tuple				       =							initializer_range
   UpperCAmelCase__      :					Union[str, Any]				       =							num_ctc_classes
   UpperCAmelCase__      :					Any				       =							vocab_size
   UpperCAmelCase__      :					Dict				       =							do_stable_layer_norm
   UpperCAmelCase__      :					List[Any]				       =							use_weighted_layer_sum
   UpperCAmelCase__      :					Optional[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
   UpperCAmelCase__      :					List[str]				       =							apply_spec_augment
   UpperCAmelCase__      :					Union[str, Any]				       =							mask_time_prob
   UpperCAmelCase__      :					List[Any]				       =							mask_time_length
   UpperCAmelCase__      :					List[str]				       =							mask_time_min_masks
   UpperCAmelCase__      :					List[str]				       =							mask_feature_prob
   UpperCAmelCase__      :					Dict				       =							mask_feature_length

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

   # ctc loss
   UpperCAmelCase__      :					Tuple				       =							ctc_loss_reduction
   UpperCAmelCase__      :					Any				       =							ctc_zero_infinity

   # adapter
   UpperCAmelCase__      :					int				       =							add_adapter
   UpperCAmelCase__      :					List[Any]				       =							adapter_kernel_size
   UpperCAmelCase__      :					Dict				       =							adapter_stride
   UpperCAmelCase__      :					Dict				       =							num_adapter_layers
   UpperCAmelCase__      :					Union[str, Any]				       =							output_hidden_size or hidden_size

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

   # XVector-specific parameters. Feel free to ignore for other classes.
   UpperCAmelCase__      :					Any				       =							list(snake_case__ )
   UpperCAmelCase__      :					List[Any]				       =							list(snake_case__ )
   UpperCAmelCase__      :					List[str]				       =							list(snake_case__ )
   UpperCAmelCase__      :					Dict				       =							xvector_output_dim







 @property
 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




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



