




import functools
import operator

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


__lowerCAmelCase	:       List[str]     =	logging.get_logger(__name__)

__lowerCAmelCase	:       Dict     =	{
    '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 					snake_case__							(A_     ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_ :							List[Any]											=      '''wavlm'''





				def __init__(   self       :  Any      ,   __lowerCamelCase       :  int=32      ,   __lowerCamelCase       :  List[str]=7_68      ,   __lowerCamelCase       :  Any=12      ,   __lowerCamelCase       :  Any=12      ,   __lowerCamelCase       :  Any=30_72      ,   __lowerCamelCase       :  List[str]="gelu"      ,   __lowerCamelCase       :  Tuple=0.1      ,   __lowerCamelCase       :  List[Any]=0.1      ,   __lowerCamelCase       :  Optional[Any]=0.1      ,   __lowerCamelCase       :  List[str]=0.0      ,   __lowerCamelCase       :  Optional[int]=0.1      ,   __lowerCamelCase       :  int=0.1      ,   __lowerCamelCase       :  Dict=0.02      ,   __lowerCamelCase       :  Any=1e-5      ,   __lowerCamelCase       :  Tuple="group"      ,   __lowerCamelCase       :  int="gelu"      ,   __lowerCamelCase       :  Optional[int]=(5_12, 5_12, 5_12, 5_12, 5_12, 5_12, 5_12)      ,   __lowerCamelCase       :  List[str]=(5, 2, 2, 2, 2, 2, 2)      ,   __lowerCamelCase       :  int=(10, 3, 3, 3, 3, 2, 2)      ,   __lowerCamelCase       :  List[str]=False      ,   __lowerCamelCase       :  Optional[int]=1_28      ,   __lowerCamelCase       :  Tuple=16      ,   __lowerCamelCase       :  int=3_20      ,   __lowerCamelCase       :  Any=8_00      ,   __lowerCamelCase       :  Optional[int]=False      ,   __lowerCamelCase       :  Optional[int]=True      ,   __lowerCamelCase       :  Dict=0.05      ,   __lowerCamelCase       :  List[str]=10      ,   __lowerCamelCase       :  Dict=2      ,   __lowerCamelCase       :  Optional[Any]=0.0      ,   __lowerCamelCase       :  str=10      ,   __lowerCamelCase       :  List[str]=3_20      ,   __lowerCamelCase       :  Dict=2      ,   __lowerCamelCase       :  int=0.1      ,   __lowerCamelCase       :  str=1_00      ,   __lowerCamelCase       :  Any=2_56      ,   __lowerCamelCase       :  List[str]=2_56      ,   __lowerCamelCase       :  Optional[int]=0.1      ,   __lowerCamelCase       :  Optional[Any]="mean"      ,   __lowerCamelCase       :  List[Any]=False      ,   __lowerCamelCase       :  str=False      ,   __lowerCamelCase       :  List[str]=2_56      ,   __lowerCamelCase       :  str=(5_12, 5_12, 5_12, 5_12, 15_00)      ,   __lowerCamelCase       :  Optional[Any]=(5, 3, 3, 1, 1)      ,   __lowerCamelCase       :  Union[str, Any]=(1, 2, 3, 1, 1)      ,   __lowerCamelCase       :  int=5_12      ,   __lowerCamelCase       :  int=80      ,   __lowerCamelCase       :  str=0      ,   __lowerCamelCase       :  Optional[int]=1      ,   __lowerCamelCase       :  Tuple=2      ,   __lowerCamelCase       :  List[str]=False      ,   __lowerCamelCase       :  Tuple=3      ,   __lowerCamelCase       :  int=2      ,   __lowerCamelCase       :  Union[str, Any]=3      ,   __lowerCamelCase       :  List[Any]=None      ,   **__lowerCamelCase       :  List[str]      ,   )      ->  List[Any]:
							super().__init__(**__lowerCamelCase      ,   pad_token_id=__lowerCamelCase      ,   bos_token_id=__lowerCamelCase      ,   eos_token_id=__lowerCamelCase							)
							a					=    hidden_size
							a					=    feat_extract_norm
							a					=    feat_extract_activation
							a					=    list(__lowerCamelCase							)
							a					=    list(__lowerCamelCase							)
							a					=    list(__lowerCamelCase							)
							a					=    conv_bias
							a					=    num_buckets
							a					=    max_bucket_distance
							a					=    num_conv_pos_embeddings
							a					=    num_conv_pos_embedding_groups
							a					=    len(self.conv_dim							)
							a					=    num_hidden_layers
							a					=    intermediate_size
							a					=    hidden_act
							a					=    num_attention_heads
							a					=    hidden_dropout
							a					=    attention_dropout
							a					=    activation_dropout
							a					=    feat_proj_dropout
							a					=    final_dropout
							a					=    layerdrop
							a					=    layer_norm_eps
							a					=    initializer_range
							a					=    num_ctc_classes
							a					=    vocab_size
							a					=    do_stable_layer_norm
							a					=    use_weighted_layer_sum
							a					=    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					=    apply_spec_augment
							a					=    mask_time_prob
							a					=    mask_time_length
							a					=    mask_time_min_masks
							a					=    mask_feature_prob
							a					=    mask_feature_length

							# parameters for pretraining with codevector quantized representations
							a					=    num_codevectors_per_group
							a					=    num_codevector_groups
							a					=    contrastive_logits_temperature
							a					=    num_negatives
							a					=    codevector_dim
							a					=    proj_codevector_dim
							a					=    diversity_loss_weight

							# ctc loss
							a					=    ctc_loss_reduction
							a					=    ctc_zero_infinity

							# adapter
							a					=    add_adapter
							a					=    adapter_kernel_size
							a					=    adapter_stride
							a					=    num_adapter_layers
							a					=    output_hidden_size or hidden_size

							# SequenceClassification-specific parameter. Feel free to ignore for other classes.
							a					=    classifier_proj_size

							# XVector-specific parameters. Feel free to ignore for other classes.
							a					=    list(__lowerCamelCase							)
							a					=    list(__lowerCamelCase							)
							a					=    list(__lowerCamelCase							)
							a					=    xvector_output_dim





				@property
				def 							__UpperCAmelCase							(   self       :  Any							)      ->  int:
							return functools.reduce(operator.mul      ,   self.conv_stride      ,   1							)












import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__lowerCAmelCase	:       int     =	logging.get_logger(__name__)


__lowerCAmelCase	:       Optional[int]     =	'▁'

__lowerCAmelCase	:       Union[str, Any]     =	{'vocab_file': 'spiece.model'}

__lowerCAmelCase	:       int     =	{
    'vocab_file': {
        'google/reformer-crime-and-punishment': (
            'https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/spiece.model'
        )
    }
}

__lowerCAmelCase	:       Any     =	{
    'google/reformer-crime-and-punishment': 52_4288,
}




class 					snake_case__							(_UpperCamelCase     ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_ :							Dict											=      VOCAB_FILES_NAMES
				SCREAMING_SNAKE_CASE_ :							int											=      PRETRAINED_VOCAB_FILES_MAP
				SCREAMING_SNAKE_CASE_ :							List[Any]											=      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				SCREAMING_SNAKE_CASE_ :							Optional[int]											=      ["""input_ids""", """attention_mask"""]





				def __init__(   self       :  List[Any]      ,   __lowerCamelCase       :  List[str]      ,   __lowerCamelCase       :  Dict="</s>"      ,   __lowerCamelCase       :  Dict="<unk>"      ,   __lowerCamelCase       :  Dict=[]      ,   __lowerCamelCase       :  Optional[Dict[str, Any]] = None      ,   **__lowerCamelCase       :  Dict      ,   )      ->  None:
							a					=    {} if sp_model_kwargs is None else sp_model_kwargs

							super().__init__(
							    eos_token=__lowerCamelCase      ,   unk_token=__lowerCamelCase      ,   additional_special_tokens=__lowerCamelCase      ,   sp_model_kwargs=self.sp_model_kwargs      ,   **__lowerCamelCase      ,   )

							a					=    vocab_file
							a					=    spm.SentencePieceProcessor(**self.sp_model_kwargs							)
							self.sp_model.Load(__lowerCamelCase							)





				@property
				def 							__UpperCAmelCase							(   self       :  Optional[int]							)      ->  int:
							return self.sp_model.get_piece_size()





				def 							__UpperCAmelCase							(   self       :  Tuple							)      ->  Dict[str, int]:
							a					=    {self.convert_ids_to_tokens(__lowerCamelCase							): i for i in range(self.vocab_size							)}
							vocab.update(self.added_tokens_encoder							)
							return vocab





				def __getstate__(   self       :  Optional[Any]							)      ->  Optional[Any]:
							a					=    self.__dict__.copy()
							a					=    None
							return state





				def __setstate__(   self       :  str      ,   __lowerCamelCase       :  Tuple							)      ->  List[Any]:
							a					=    d

							# for backward compatibility
							if not hasattr(self      ,   "sp_model_kwargs"							):
										a					=    {}

							a					=    spm.SentencePieceProcessor(**self.sp_model_kwargs							)
							self.sp_model.Load(self.vocab_file							)





				def 							__UpperCAmelCase							(   self       :  int      ,   __lowerCamelCase       :  str							)      ->  List[str]:
							return self.sp_model.encode(__lowerCamelCase      ,   out_type=__lowerCamelCase							)





				def 							__UpperCAmelCase							(   self       :  List[Any]      ,   __lowerCamelCase       :  Dict							)      ->  Any:
							return self.sp_model.piece_to_id(__lowerCamelCase							)





				def 							__UpperCAmelCase							(   self       :  int      ,   __lowerCamelCase       :  Union[str, Any]							)      ->  str:
							if index < self.sp_model.get_piece_size():
										a					=    self.sp_model.IdToPiece(__lowerCamelCase							)
							return token





				def 							__UpperCAmelCase							(   self       :  Optional[int]      ,   __lowerCamelCase       :  Optional[Any]							)      ->  List[Any]:
							a					=    []
							a					=    ""
							for token in tokens:
										# make sure that special tokens are not decoded using sentencepiece model
										if token in self.all_special_tokens:
													out_string += self.sp_model.decode(__lowerCamelCase							) + token
													a					=    []
										else:
													current_sub_tokens.append(__lowerCamelCase							)
							out_string += self.sp_model.decode(__lowerCamelCase							)
							return out_string.strip()





				def 							__UpperCAmelCase							(   self       :  Any      ,   __lowerCamelCase       :  str      ,   __lowerCamelCase       :  Optional[str] = None							)      ->  Tuple[str]:
							if not os.path.isdir(__lowerCamelCase							):
										logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""							)
										return
							a					=    os.path.join(
							    __lowerCamelCase      ,   (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]							)

							if os.path.abspath(self.vocab_file							) != os.path.abspath(__lowerCamelCase							) and os.path.isfile(self.vocab_file							):
										copyfile(self.vocab_file      ,   __lowerCamelCase							)
							elif not os.path.isfile(self.vocab_file							):
										with open(__lowerCamelCase      ,   "wb"							) as fi:
													a					=    self.sp_model.serialized_model_proto()
													fi.write(__lowerCamelCase							)

							return (out_vocab_file,)






