

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()






class 					_UpperCamelCase							(							unittest.TestCase   ):
			'''simple docstring'''







			def 							__UpperCamelCase (			self							: int	)							->       List[Any]:

				"""simple docstring"""

				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()
			@property
			def 							__UpperCamelCase (			self							: Any	)							->       Tuple:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Any				     =       1
				SCREAMING_SNAKE_CASE   :      Any				     =       3
				SCREAMING_SNAKE_CASE   :      str				     =       (32, 32)

				SCREAMING_SNAKE_CASE   :      List[Any]				     =       floats_tensor((batch_size, num_channels) + sizes      ,      rng=random.Random(0	)	).to(lowerCamelCase_	)
				return image
			@property
			def 							__UpperCamelCase (			self							: List[str]	)							->       Tuple:

				"""simple docstring"""

				torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Any				     =       UNetaDConditionModel(
				    block_out_channels=(32, 32, 64)      ,      layers_per_block=2      ,      sample_size=32      ,      in_channels=7      ,      out_channels=4      ,      down_block_types=("DownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D")      ,      up_block_types=("CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "UpBlock2D")      ,      cross_attention_dim=32      ,      attention_head_dim=8      ,      use_linear_projection=lowerCamelCase_      ,      only_cross_attention=(True, True, False)      ,      num_class_embeds=100      ,      )
				return model
			@property
			def 							__UpperCamelCase (			self							: List[str]	)							->       str:

				"""simple docstring"""

				torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Dict				     =       AutoencoderKL(
				    block_out_channels=[32, 32, 64]      ,      in_channels=3      ,      out_channels=3      ,      down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D", "DownEncoderBlock2D"]      ,      up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"]      ,      latent_channels=4      ,      )
				return model
			@property
			def 							__UpperCamelCase (			self							: Tuple	)							->       Optional[Any]:

				"""simple docstring"""

				torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       CLIPTextConfig(
				    bos_token_id=0      ,      eos_token_id=2      ,      hidden_size=32      ,      intermediate_size=37      ,      layer_norm_eps=1e-05      ,      num_attention_heads=4      ,      num_hidden_layers=5      ,      pad_token_id=1      ,      vocab_size=1000      ,      hidden_act="gelu"      ,      projection_dim=512      ,      )
				return CLIPTextModel(lowerCamelCase_	)
			def 							__UpperCamelCase (			self							: Tuple	)							->       Optional[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      int				     =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
				SCREAMING_SNAKE_CASE   :      Tuple				     =       self.dummy_cond_unet_upscale
				SCREAMING_SNAKE_CASE   :      int				     =       DDPMScheduler()
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       DDIMScheduler(prediction_type="v_prediction"	)
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       self.dummy_vae
				SCREAMING_SNAKE_CASE   :      Tuple				     =       self.dummy_text_encoder
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

				SCREAMING_SNAKE_CASE   :      List[Any]				     =       self.dummy_image.cpu().permute(0      ,      2      ,      3      ,      1	)[0]
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       Image.fromarray(np.uinta(lowerCamelCase_	)	).convert("RGB"	).resize((64, 64)	)

				# make sure here that pndm scheduler skips prk
				SCREAMING_SNAKE_CASE   :      int				     =       StableDiffusionUpscalePipeline(
				    unet=lowerCamelCase_      ,      low_res_scheduler=lowerCamelCase_      ,      scheduler=lowerCamelCase_      ,      vae=lowerCamelCase_      ,      text_encoder=lowerCamelCase_      ,      tokenizer=lowerCamelCase_      ,      max_noise_level=350      ,      )
				SCREAMING_SNAKE_CASE   :      str				     =       sd_pipe.to(lowerCamelCase_	)
				sd_pipe.set_progress_bar_config(disable=lowerCamelCase_	)

				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       '''A painting of a squirrel eating a burger'''
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       torch.Generator(device=lowerCamelCase_	).manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       sd_pipe(
				    [prompt]      ,      image=lowerCamelCase_      ,      generator=lowerCamelCase_      ,      guidance_scale=6.0      ,      noise_level=20      ,      num_inference_steps=2      ,      output_type="np"      ,      )

				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       output.images

				SCREAMING_SNAKE_CASE   :      List[Any]				     =       torch.Generator(device=lowerCamelCase_	).manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Tuple				     =       sd_pipe(
				    [prompt]      ,      image=lowerCamelCase_      ,      generator=lowerCamelCase_      ,      guidance_scale=6.0      ,      noise_level=20      ,      num_inference_steps=2      ,      output_type="np"      ,      return_dict=lowerCamelCase_      ,      )[0]

				SCREAMING_SNAKE_CASE   :      str				     =       image[0, -3:, -3:, -1]
				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       image_from_tuple[0, -3:, -3:, -1]

				SCREAMING_SNAKE_CASE   :      List[str]				     =       low_res_image.size[0] * 4
				assert image.shape == (1, expected_height_width, expected_height_width, 3)
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661]	)

				assert np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
				assert np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1e-2
			def 							__UpperCamelCase (			self							: List[str]	)							->       Tuple:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Dict				     =       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       self.dummy_cond_unet_upscale
				SCREAMING_SNAKE_CASE   :      Any				     =       DDPMScheduler()
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       DDIMScheduler(prediction_type="v_prediction"	)
				SCREAMING_SNAKE_CASE   :      List[str]				     =       self.dummy_vae
				SCREAMING_SNAKE_CASE   :      int				     =       self.dummy_text_encoder
				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       self.dummy_image.cpu().permute(0      ,      2      ,      3      ,      1	)[0]
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       Image.fromarray(np.uinta(lowerCamelCase_	)	).convert("RGB"	).resize((64, 64)	)

				# make sure here that pndm scheduler skips prk
				SCREAMING_SNAKE_CASE   :      int				     =       StableDiffusionUpscalePipeline(
				    unet=lowerCamelCase_      ,      low_res_scheduler=lowerCamelCase_      ,      scheduler=lowerCamelCase_      ,      vae=lowerCamelCase_      ,      text_encoder=lowerCamelCase_      ,      tokenizer=lowerCamelCase_      ,      max_noise_level=350      ,      )
				SCREAMING_SNAKE_CASE   :      Any				     =       sd_pipe.to(lowerCamelCase_	)
				sd_pipe.set_progress_bar_config(disable=lowerCamelCase_	)

				SCREAMING_SNAKE_CASE   :      int				     =       '''A painting of a squirrel eating a burger'''
				SCREAMING_SNAKE_CASE   :      List[str]				     =       sd_pipe(
				    2 * [prompt]      ,      image=2 * [low_res_image]      ,      guidance_scale=6.0      ,      noise_level=20      ,      num_inference_steps=2      ,      output_type="np"      ,      )
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       output.images
				assert image.shape[0] == 2

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       torch.Generator(device=lowerCamelCase_	).manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       sd_pipe(
				    [prompt]      ,      image=lowerCamelCase_      ,      generator=lowerCamelCase_      ,      num_images_per_prompt=2      ,      guidance_scale=6.0      ,      noise_level=20      ,      num_inference_steps=2      ,      output_type="np"      ,      )
				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       output.images
				assert image.shape[0] == 2






			@unittest.skipIf(torch_device != "cuda"      ,      "This test requires a GPU"	)
			def 							__UpperCamelCase (			self							: Union[str, Any]	)							->       Optional[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      List[str]				     =       self.dummy_cond_unet_upscale
				SCREAMING_SNAKE_CASE   :      Dict				     =       DDPMScheduler()
				SCREAMING_SNAKE_CASE   :      str				     =       DDIMScheduler(prediction_type="v_prediction"	)
				SCREAMING_SNAKE_CASE   :      int				     =       self.dummy_vae
				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       self.dummy_text_encoder
				SCREAMING_SNAKE_CASE   :      Any				     =       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)

				SCREAMING_SNAKE_CASE   :      str				     =       self.dummy_image.cpu().permute(0      ,      2      ,      3      ,      1	)[0]
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       Image.fromarray(np.uinta(lowerCamelCase_	)	).convert("RGB"	).resize((64, 64)	)

				# put models in fp16, except vae as it overflows in fp16
				SCREAMING_SNAKE_CASE   :      List[str]				     =       unet.half()
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       text_encoder.half()

				# make sure here that pndm scheduler skips prk
				SCREAMING_SNAKE_CASE   :      int				     =       StableDiffusionUpscalePipeline(
				    unet=lowerCamelCase_      ,      low_res_scheduler=lowerCamelCase_      ,      scheduler=lowerCamelCase_      ,      vae=lowerCamelCase_      ,      text_encoder=lowerCamelCase_      ,      tokenizer=lowerCamelCase_      ,      max_noise_level=350      ,      )
				SCREAMING_SNAKE_CASE   :      Any				     =       sd_pipe.to(lowerCamelCase_	)
				sd_pipe.set_progress_bar_config(disable=lowerCamelCase_	)

				SCREAMING_SNAKE_CASE   :      Any				     =       '''A painting of a squirrel eating a burger'''
				SCREAMING_SNAKE_CASE   :      Any				     =       torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Dict				     =       sd_pipe(
				    [prompt]      ,      image=lowerCamelCase_      ,      generator=lowerCamelCase_      ,      num_inference_steps=2      ,      output_type="np"      ,      ).images

				SCREAMING_SNAKE_CASE   :      Any				     =       low_res_image.size[0] * 4
				assert image.shape == (1, expected_height_width, expected_height_width, 3)






@slow
@require_torch_gpu
class 					_UpperCamelCase							(							unittest.TestCase   ):
			'''simple docstring'''







			def 							__UpperCamelCase (			self							: Optional[int]	)							->       List[Any]:

				"""simple docstring"""

				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()
			def 							__UpperCamelCase (			self							: List[Any]	)							->       List[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      List[Any]				     =       load_image(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/sd2-upscale/low_res_cat.png"	)
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       load_numpy(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
				    "/upsampled_cat.npy"	)

				SCREAMING_SNAKE_CASE   :      Dict				     =       '''stabilityai/stable-diffusion-x4-upscaler'''
				SCREAMING_SNAKE_CASE   :      Tuple				     =       StableDiffusionUpscalePipeline.from_pretrained(lowerCamelCase_	)
				pipe.to(lowerCamelCase_	)
				pipe.set_progress_bar_config(disable=lowerCamelCase_	)
				pipe.enable_attention_slicing()

				SCREAMING_SNAKE_CASE   :      Dict				     =       '''a cat sitting on a park bench'''

				SCREAMING_SNAKE_CASE   :      str				     =       torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Any				     =       pipe(
				    prompt=lowerCamelCase_      ,      image=lowerCamelCase_      ,      generator=lowerCamelCase_      ,      output_type="np"      ,      )
				SCREAMING_SNAKE_CASE   :      Dict				     =       output.images[0]

				assert image.shape == (512, 512, 3)
				assert np.abs(expected_image - image	).max() < 1e-3
			def 							__UpperCamelCase (			self							: Any	)							->       int:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      Dict				     =       load_image(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/sd2-upscale/low_res_cat.png"	)
				SCREAMING_SNAKE_CASE   :      int				     =       load_numpy(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
				    "/upsampled_cat_fp16.npy"	)

				SCREAMING_SNAKE_CASE   :      List[Any]				     =       '''stabilityai/stable-diffusion-x4-upscaler'''
				SCREAMING_SNAKE_CASE   :      Any				     =       StableDiffusionUpscalePipeline.from_pretrained(
				    lowerCamelCase_      ,      torch_dtype=torch.floataa      ,      )
				pipe.to(lowerCamelCase_	)
				pipe.set_progress_bar_config(disable=lowerCamelCase_	)
				pipe.enable_attention_slicing()

				SCREAMING_SNAKE_CASE   :      Tuple				     =       '''a cat sitting on a park bench'''

				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       pipe(
				    prompt=lowerCamelCase_      ,      image=lowerCamelCase_      ,      generator=lowerCamelCase_      ,      output_type="np"      ,      )
				SCREAMING_SNAKE_CASE   :      Tuple				     =       output.images[0]

				assert image.shape == (512, 512, 3)
				assert np.abs(expected_image - image	).max() < 5e-1






			def 							__UpperCamelCase (			self							: Tuple	)							->       Dict:

				"""simple docstring"""

				torch.cuda.empty_cache()
				torch.cuda.reset_max_memory_allocated()
				torch.cuda.reset_peak_memory_stats()

				SCREAMING_SNAKE_CASE   :      Dict				     =       load_image(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/sd2-upscale/low_res_cat.png"	)

				SCREAMING_SNAKE_CASE   :      List[str]				     =       '''stabilityai/stable-diffusion-x4-upscaler'''
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       StableDiffusionUpscalePipeline.from_pretrained(
				    lowerCamelCase_      ,      torch_dtype=torch.floataa      ,      )
				pipe.to(lowerCamelCase_	)
				pipe.set_progress_bar_config(disable=lowerCamelCase_	)
				pipe.enable_attention_slicing(1	)
				pipe.enable_sequential_cpu_offload()

				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       '''a cat sitting on a park bench'''

				SCREAMING_SNAKE_CASE   :      str				     =       torch.manual_seed(0	)
				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       pipe(
				    prompt=lowerCamelCase_      ,      image=lowerCamelCase_      ,      generator=lowerCamelCase_      ,      num_inference_steps=5      ,      output_type="np"      ,      )

				SCREAMING_SNAKE_CASE   :      Dict				     =       torch.cuda.max_memory_allocated()
				# make sure that less than 2.9 GB is allocated
				assert mem_bytes < 2.9 * 10**9


import functools
import operator

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


a_						     =    logging.get_logger(__name__)

a_						     =    {
    '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'''







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

				"""simple docstring"""

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

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

				# ctc loss
				SCREAMING_SNAKE_CASE   :      Any				     =       ctc_loss_reduction
				SCREAMING_SNAKE_CASE   :      Dict				     =       ctc_zero_infinity

				# adapter
				SCREAMING_SNAKE_CASE   :      Any				     =       add_adapter
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       adapter_kernel_size
				SCREAMING_SNAKE_CASE   :      Any				     =       adapter_stride
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       num_adapter_layers
				SCREAMING_SNAKE_CASE   :      int				     =       output_hidden_size or hidden_size

				# SequenceClassification-specific parameter. Feel free to ignore for other classes.
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       classifier_proj_size

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






			@property
			def 							__UpperCamelCase (			self							: int	)							->       Union[str, Any]:

				"""simple docstring"""

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