




"""simple docstring"""





import functools
import operator

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


A   =       logging.get_logger(__name__)

A   =       {
    """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__				(	__snake_case   ):
			lowercase_    =	"unispeech-sat"


			def __init__(      self      :    int      ,  UpperCamelCase_      :    List[str]=32      ,  UpperCamelCase_      :    Any=768      ,  UpperCamelCase_      :    int=12      ,  UpperCamelCase_      :    str=12      ,  UpperCamelCase_      :    Tuple=3072      ,  UpperCamelCase_      :    Tuple="gelu"      ,  UpperCamelCase_      :    Optional[int]=0.1      ,  UpperCamelCase_      :    List[str]=0.1      ,  UpperCamelCase_      :    Dict=0.1      ,  UpperCamelCase_      :    Tuple=0.0      ,  UpperCamelCase_      :    Optional[Any]=0.0      ,  UpperCamelCase_      :    str=0.1      ,  UpperCamelCase_      :    Any=0.1      ,  UpperCamelCase_      :    List[Any]=0.02      ,  UpperCamelCase_      :    int=1e-5      ,  UpperCamelCase_      :    Union[str, Any]="group"      ,  UpperCamelCase_      :    str="gelu"      ,  UpperCamelCase_      :    Union[str, Any]=(512, 512, 512, 512, 512, 512, 512)      ,  UpperCamelCase_      :    int=(5, 2, 2, 2, 2, 2, 2)      ,  UpperCamelCase_      :    Tuple=(10, 3, 3, 3, 3, 2, 2)      ,  UpperCamelCase_      :    Any=False      ,  UpperCamelCase_      :    int=128      ,  UpperCamelCase_      :    Tuple=16      ,  UpperCamelCase_      :    Optional[Any]=False      ,  UpperCamelCase_      :    List[Any]=True      ,  UpperCamelCase_      :    Dict=0.05      ,  UpperCamelCase_      :    Any=10      ,  UpperCamelCase_      :    Optional[int]=2      ,  UpperCamelCase_      :    Optional[Any]=0.0      ,  UpperCamelCase_      :    Any=10      ,  UpperCamelCase_      :    Tuple=0      ,  UpperCamelCase_      :    Tuple=320      ,  UpperCamelCase_      :    Optional[int]=2      ,  UpperCamelCase_      :    Optional[int]=0.1      ,  UpperCamelCase_      :    Union[str, Any]=100      ,  UpperCamelCase_      :    Union[str, Any]=256      ,  UpperCamelCase_      :    int=256      ,  UpperCamelCase_      :    Tuple=0.1      ,  UpperCamelCase_      :    Optional[int]="mean"      ,  UpperCamelCase_      :    Union[str, Any]=False      ,  UpperCamelCase_      :    str=False      ,  UpperCamelCase_      :    Tuple=256      ,  UpperCamelCase_      :    List[Any]=(512, 512, 512, 512, 1500)      ,  UpperCamelCase_      :    int=(5, 3, 3, 1, 1)      ,  UpperCamelCase_      :    Optional[int]=(1, 2, 3, 1, 1)      ,  UpperCamelCase_      :    Union[str, Any]=512      ,  UpperCamelCase_      :    List[str]=0      ,  UpperCamelCase_      :    List[str]=1      ,  UpperCamelCase_      :    Dict=2      ,  UpperCamelCase_      :    List[Any]=504      ,  **UpperCamelCase_      :    List[str]      ,  ):


						"""simple docstring"""




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

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

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

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

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


			@property
			def       a_     (      self      :    Optional[Any]):


						"""simple docstring"""




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








"""simple docstring"""





def 					_UpperCamelCase    (			UpperCamelCase				,       UpperCamelCase = False							)			->			bool:


			"""simple docstring"""
			if n == 2:
						return True
			if not n % 2 or n < 2:
						return False
			if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
						return False
			if n > 3_3170_4406_4679_8873_8596_1981 and not allow_probable:
						raise ValueError(
						    "Warning: upper bound of deterministic test is exceeded. "
						    "Pass allow_probable=True to allow probabilistic test. "
						    "A return value of True indicates a probable prime."							)
			# array bounds provided by analysis
			__UpperCAmelCase	: List[str]		=					[
			    2047,
			    137_3653,
			    2532_6001,
			    32_1503_1751,
			    2_1523_0289_8747,
			    3_4747_4966_0383,
			    341_5500_7172_8321,
			    1,
			    382_5123_0565_4641_3051,
			    1,
			    1,
			    3186_6585_7834_0311_5116_7461,
			    3_3170_4406_4679_8873_8596_1981,
			]

			__UpperCAmelCase	: Tuple		=					[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
			for idx, _p in enumerate(UpperCamelCase				,       1							):
						if n < _p:
									# then we have our last prime to check
									__UpperCAmelCase	: Tuple		=					primes[:idx]
									break
			__UpperCAmelCase	,     __UpperCAmelCase	: List[str]		=					n - 1, 0
			# break up n -1 into a power of 2 (s) and
			# remaining odd component
			# essentially, solve for d * 2 ** s == n - 1
			while d % 2 == 0:
						d //= 2
						s += 1
			for prime in plist:
						__UpperCAmelCase	: Optional[int]		=					False
						for r in range(UpperCamelCase							):
									__UpperCAmelCase	: Dict		=					pow(UpperCamelCase				,       d * 2**r				,       UpperCamelCase							)
									# see article for analysis explanation for m
									if (r == 0 and m == 1) or ((m + 1) % n == 0):
												__UpperCAmelCase	: Optional[int]		=					True
												# this loop will not determine compositeness
												break
						if pr:
									continue
						# if pr is False, then the above loop never evaluated to true,
						# and the n MUST be composite
						return False
			return True

def 					_UpperCamelCase    (			)			->			None:


			"""simple docstring"""
			assert not miller_rabin(561							)
			assert miller_rabin(563							)
			# 2047

			assert not miller_rabin(83_8201							)
			assert miller_rabin(83_8207							)
			# 1_373_653

			assert not miller_rabin(1731_6001							)
			assert miller_rabin(1731_6017							)
			# 25_326_001

			assert not miller_rabin(30_7838_6641							)
			assert miller_rabin(30_7838_6653							)
			# 3_215_031_751

			assert not miller_rabin(1_7130_4557_4801							)
			assert miller_rabin(1_7130_4557_4819							)
			# 2_152_302_898_747

			assert not miller_rabin(2_7797_9972_8307							)
			assert miller_rabin(2_7797_9972_8327							)
			# 3_474_749_660_383

			assert not miller_rabin(113_8500_2390_9441							)
			assert miller_rabin(113_8500_2390_9527							)
			# 341_550_071_728_321

			assert not miller_rabin(127_5041_0188_4880_4351							)
			assert miller_rabin(127_5041_0188_4880_4391							)
			# 3_825_123_056_546_413_051

			assert not miller_rabin(796_6646_4458_5077_8779_1867							)
			assert miller_rabin(796_6646_4458_5077_8779_1951							)
			# 318_665_857_834_031_151_167_461

			assert not miller_rabin(5528_4067_7446_6478_9766_0333							)
			assert miller_rabin(5528_4067_7446_6478_9766_0359							)
			# 3_317_044_064_679_887_385_961_981
			# upper limit for probabilistic test


if __name__ == "__main__":
					test_miller_rabin()


