'''simple docstring'''




import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()




class    a__				(       UpperCAmelCase__							,       unittest.TestCase			):
     lowerCamelCase  :					Union[str, Any]							=UnCLIPImageVariationPipeline
     lowerCamelCase  :					Any							=IMAGE_VARIATION_PARAMS - {"height", "width", "guidance_scale"}
     lowerCamelCase  :					List[str]							=IMAGE_VARIATION_BATCH_PARAMS

     lowerCamelCase  :					List[str]							=[
         "generator",
         "return_dict",
         "decoder_num_inference_steps",
         "super_res_num_inference_steps",
     ]
     lowerCamelCase  :					str							=False






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Dict   ):





         """simple docstring"""



         return 32






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Dict   ):





         """simple docstring"""



         return 32






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		List[Any]   ):





         """simple docstring"""



         return self.time_input_dim






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Union[str, Any]   ):





         """simple docstring"""



         return self.time_input_dim * 4






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         return 1_00






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Dict   ):





         """simple docstring"""



         __lowerCamelCase          =  CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''   )
         return tokenizer






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		str   ):





         """simple docstring"""



         torch.manual_seed(0   )
         __lowerCamelCase          =  CLIPTextConfig(
             bos_token_id=0  ,    eos_token_id=2  ,    hidden_size=self.text_embedder_hidden_size  ,    projection_dim=self.text_embedder_hidden_size  ,    intermediate_size=37  ,    layer_norm_eps=1e-0_5  ,    num_attention_heads=4  ,    num_hidden_layers=5  ,    pad_token_id=1  ,    vocab_size=10_00  ,    )
         return CLIPTextModelWithProjection(a   )






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





         """simple docstring"""



         torch.manual_seed(0   )
         __lowerCamelCase          =  CLIPVisionConfig(
             hidden_size=self.text_embedder_hidden_size  ,    projection_dim=self.text_embedder_hidden_size  ,    num_hidden_layers=5  ,    num_attention_heads=4  ,    image_size=32  ,    intermediate_size=37  ,    patch_size=1  ,    )
         return CLIPVisionModelWithProjection(a   )






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Any   ):





         """simple docstring"""



         torch.manual_seed(0   )

         __lowerCamelCase          =  {
             '''clip_embeddings_dim''': self.text_embedder_hidden_size,
             '''time_embed_dim''': self.time_embed_dim,
             '''cross_attention_dim''': self.cross_attention_dim,
         }

         __lowerCamelCase          =  UnCLIPTextProjModel(**a   )
         return model






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		List[str]   ):





         """simple docstring"""



         torch.manual_seed(0   )

         __lowerCamelCase          =  {
             '''sample_size''': 32,
             # RGB in channels
             '''in_channels''': 3,
             # Out channels is double in channels because predicts mean and variance
             '''out_channels''': 6,
             '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
             '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
             '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
             '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
             '''layers_per_block''': 1,
             '''cross_attention_dim''': self.cross_attention_dim,
             '''attention_head_dim''': 4,
             '''resnet_time_scale_shift''': '''scale_shift''',
             '''class_embed_type''': '''identity''',
         }

         __lowerCamelCase          =  UNetaDConditionModel(**a   )
         return model






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





         """simple docstring"""



         return {
             "sample_size": 64,
             "layers_per_block": 1,
             "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
             "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
             "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
             "in_channels": 6,
             "out_channels": 3,
         }






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		int   ):





         """simple docstring"""



         torch.manual_seed(0   )

         __lowerCamelCase          =  UNetaDModel(**self.dummy_super_res_kwargs   )
         return model






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Any   ):





         """simple docstring"""



         torch.manual_seed(1   )

         __lowerCamelCase          =  UNetaDModel(**self.dummy_super_res_kwargs   )
         return model






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         __lowerCamelCase          =  self.dummy_decoder
         __lowerCamelCase          =  self.dummy_text_proj
         __lowerCamelCase          =  self.dummy_text_encoder
         __lowerCamelCase          =  self.dummy_tokenizer
         __lowerCamelCase          =  self.dummy_super_res_first
         __lowerCamelCase          =  self.dummy_super_res_last

         __lowerCamelCase          =  UnCLIPScheduler(
             variance_type='''learned_range'''  ,    prediction_type='''epsilon'''  ,    num_train_timesteps=10_00  ,    )

         __lowerCamelCase          =  UnCLIPScheduler(
             variance_type='''fixed_small_log'''  ,    prediction_type='''epsilon'''  ,    num_train_timesteps=10_00  ,    )

         __lowerCamelCase          =  CLIPImageProcessor(crop_size=32  ,    size=32   )

         __lowerCamelCase          =  self.dummy_image_encoder

         return {
             "decoder": decoder,
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "text_proj": text_proj,
             "feature_extractor": feature_extractor,
             "image_encoder": image_encoder,
             "super_res_first": super_res_first,
             "super_res_last": super_res_last,
             "decoder_scheduler": decoder_scheduler,
             "super_res_scheduler": super_res_scheduler,
         }






     def        SCREAMING_SNAKE_CASE__       (			self		:		Tuple  ,    a		:		Tuple  ,    a		:		int=0  ,    a		:		str=True   ):





         """simple docstring"""



         __lowerCamelCase          =  floats_tensor((1, 3, 32, 32)  ,    rng=random.Random(a   )   ).to(a   )
         if str(a   ).startswith('''mps'''   ):
             __lowerCamelCase          =  torch.manual_seed(a   )
         else:
             __lowerCamelCase          =  torch.Generator(device=a   ).manual_seed(a   )

         if pil_image:
             __lowerCamelCase          =  input_image * 0.5 + 0.5
             __lowerCamelCase          =  input_image.clamp(0  ,    1   )
             __lowerCamelCase          =  input_image.cpu().permute(0  ,    2  ,    3  ,    1   ).float().numpy()
             __lowerCamelCase          =  DiffusionPipeline.numpy_to_pil(a   )[0]

         return {
             "image": input_image,
             "generator": generator,
             "decoder_num_inference_steps": 2,
             "super_res_num_inference_steps": 2,
             "output_type": "np",
         }






     def        SCREAMING_SNAKE_CASE__       (			self		:		int   ):





         """simple docstring"""



         __lowerCamelCase          =  '''cpu'''

         __lowerCamelCase          =  self.get_dummy_components()

         __lowerCamelCase          =  self.pipeline_class(**a   )
         __lowerCamelCase          =  pipe.to(a   )

         pipe.set_progress_bar_config(disable=a   )

         __lowerCamelCase          =  self.get_dummy_inputs(a  ,    pil_image=a   )

         __lowerCamelCase          =  pipe(**a   )
         __lowerCamelCase          =  output.images

         __lowerCamelCase          =  self.get_dummy_inputs(a  ,    pil_image=a   )

         __lowerCamelCase          =  pipe(
             **a  ,    return_dict=a  ,    )[0]

         __lowerCamelCase          =  image[0, -3:, -3:, -1]
         __lowerCamelCase          =  image_from_tuple[0, -3:, -3:, -1]

         assert image.shape == (1, 64, 64, 3)

         __lowerCamelCase          =  np.array(
             [
                 0.99_97,
                 0.00_02,
                 0.99_97,
                 0.99_97,
                 0.99_69,
                 0.00_23,
                 0.99_97,
                 0.99_69,
                 0.99_70,
             ]   )

         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        SCREAMING_SNAKE_CASE__       (			self		:		List[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  '''cpu'''

         __lowerCamelCase          =  self.get_dummy_components()

         __lowerCamelCase          =  self.pipeline_class(**a   )
         __lowerCamelCase          =  pipe.to(a   )

         pipe.set_progress_bar_config(disable=a   )

         __lowerCamelCase          =  self.get_dummy_inputs(a  ,    pil_image=a   )

         __lowerCamelCase          =  pipe(**a   )
         __lowerCamelCase          =  output.images

         __lowerCamelCase          =  self.get_dummy_inputs(a  ,    pil_image=a   )

         __lowerCamelCase          =  pipe(
             **a  ,    return_dict=a  ,    )[0]

         __lowerCamelCase          =  image[0, -3:, -3:, -1]
         __lowerCamelCase          =  image_from_tuple[0, -3:, -3:, -1]

         assert image.shape == (1, 64, 64, 3)

         __lowerCamelCase          =  np.array([0.99_97, 0.00_03, 0.99_97, 0.99_97, 0.99_70, 0.00_24, 0.99_97, 0.99_71, 0.99_71]   )

         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        SCREAMING_SNAKE_CASE__       (			self		:		int   ):





         """simple docstring"""



         __lowerCamelCase          =  '''cpu'''

         __lowerCamelCase          =  self.get_dummy_components()

         __lowerCamelCase          =  self.pipeline_class(**a   )
         __lowerCamelCase          =  pipe.to(a   )

         pipe.set_progress_bar_config(disable=a   )

         __lowerCamelCase          =  self.get_dummy_inputs(a  ,    pil_image=a   )
         __lowerCamelCase          =  [
             pipeline_inputs['''image'''],
             pipeline_inputs['''image'''],
         ]

         __lowerCamelCase          =  pipe(**a   )
         __lowerCamelCase          =  output.images

         __lowerCamelCase          =  self.get_dummy_inputs(a  ,    pil_image=a   )
         __lowerCamelCase          =  [
             tuple_pipeline_inputs['''image'''],
             tuple_pipeline_inputs['''image'''],
         ]

         __lowerCamelCase          =  pipe(
             **a  ,    return_dict=a  ,    )[0]

         __lowerCamelCase          =  image[0, -3:, -3:, -1]
         __lowerCamelCase          =  image_from_tuple[0, -3:, -3:, -1]

         assert image.shape == (2, 64, 64, 3)

         __lowerCamelCase          =  np.array(
             [
                 0.99_97,
                 0.99_89,
                 0.00_08,
                 0.00_21,
                 0.99_60,
                 0.00_18,
                 0.00_14,
                 0.00_02,
                 0.99_33,
             ]   )

         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        SCREAMING_SNAKE_CASE__       (			self		:		Any   ):





         """simple docstring"""



         __lowerCamelCase          =  torch.device('''cpu'''   )




         class    a__				:
              lowerCamelCase  :					List[str]							=1
         __lowerCamelCase          =  self.get_dummy_components()

         __lowerCamelCase          =  self.pipeline_class(**a   )
         __lowerCamelCase          =  pipe.to(a   )

         pipe.set_progress_bar_config(disable=a   )

         __lowerCamelCase          =  torch.Generator(device=a   ).manual_seed(0   )
         __lowerCamelCase          =  pipe.decoder.dtype
         __lowerCamelCase          =  1

         __lowerCamelCase          =  (
             batch_size,
             pipe.decoder.config.in_channels,
             pipe.decoder.config.sample_size,
             pipe.decoder.config.sample_size,
         )
         __lowerCamelCase          =  pipe.prepare_latents(
             a  ,    dtype=a  ,    device=a  ,    generator=a  ,    latents=a  ,    scheduler=DummyScheduler()   )

         __lowerCamelCase          =  (
             batch_size,
             pipe.super_res_first.config.in_channels // 2,
             pipe.super_res_first.config.sample_size,
             pipe.super_res_first.config.sample_size,
         )
         __lowerCamelCase          =  pipe.prepare_latents(
             a  ,    dtype=a  ,    device=a  ,    generator=a  ,    latents=a  ,    scheduler=DummyScheduler()   )

         __lowerCamelCase          =  self.get_dummy_inputs(a  ,    pil_image=a   )

         __lowerCamelCase          =  pipe(
             **a  ,    decoder_latents=a  ,    super_res_latents=a   ).images

         __lowerCamelCase          =  self.get_dummy_inputs(a  ,    pil_image=a   )
         # Don't pass image, instead pass embedding
         __lowerCamelCase          =  pipeline_inputs.pop('''image'''   )
         __lowerCamelCase          =  pipe.image_encoder(a   ).image_embeds

         __lowerCamelCase          =  pipe(
             **a  ,    decoder_latents=a  ,    super_res_latents=a  ,    image_embeddings=a  ,    ).images

         # make sure passing text embeddings manually is identical
         assert np.abs(img_out_a - img_out_a   ).max() < 1e-4






     @skip_mps
     def        SCREAMING_SNAKE_CASE__       (			self		:		str   ):





         """simple docstring"""



         __lowerCamelCase          =  torch_device == '''cpu'''

         # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
         __lowerCamelCase          =  1e-2

         self._test_attention_slicing_forward_pass(
             test_max_difference=a  ,    expected_max_diff=a   )






     @skip_mps
     def        SCREAMING_SNAKE_CASE__       (			self		:		Tuple   ):





         """simple docstring"""



         __lowerCamelCase          =  torch_device == '''cpu'''
         __lowerCamelCase          =  True
         __lowerCamelCase          =  [
             '''decoder_num_inference_steps''',
             '''super_res_num_inference_steps''',
         ]

         self._test_inference_batch_single_identical(
             test_max_difference=a  ,    relax_max_difference=a  ,    additional_params_copy_to_batched_inputs=a  ,    )






     def        SCREAMING_SNAKE_CASE__       (			self		:		str   ):





         """simple docstring"""



         __lowerCamelCase          =  [
             '''decoder_num_inference_steps''',
             '''super_res_num_inference_steps''',
         ]

         if torch_device == "mps":
             # TODO: MPS errors with larger batch sizes
             __lowerCamelCase          =  [2, 3]
             self._test_inference_batch_consistent(
                 batch_sizes=a  ,    additional_params_copy_to_batched_inputs=a  ,    )
         else:
             self._test_inference_batch_consistent(
                 additional_params_copy_to_batched_inputs=a   )






     @skip_mps
     def        SCREAMING_SNAKE_CASE__       (			self		:		List[str]   ):





         """simple docstring"""



         return super().test_dict_tuple_outputs_equivalent()






     @skip_mps
     def        SCREAMING_SNAKE_CASE__       (			self		:		str   ):





         """simple docstring"""



         return super().test_save_load_local()






     @skip_mps
     def        SCREAMING_SNAKE_CASE__       (			self		:		str   ):





         """simple docstring"""



         return super().test_save_load_optional_components()




@slow
@require_torch_gpu
class    a__				(       unittest.TestCase			):






     def        SCREAMING_SNAKE_CASE__       (			self		:		Dict   ):





         """simple docstring"""



         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()






     def        SCREAMING_SNAKE_CASE__       (			self		:		Tuple   ):





         """simple docstring"""



         __lowerCamelCase          =  load_image(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png'''   )
         __lowerCamelCase          =  load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
             '''/unclip/karlo_v1_alpha_cat_variation_fp16.npy'''   )

         __lowerCamelCase          =  UnCLIPImageVariationPipeline.from_pretrained(
             '''kakaobrain/karlo-v1-alpha-image-variations'''  ,    torch_dtype=torch.floataa   )
         __lowerCamelCase          =  pipeline.to(a   )
         pipeline.set_progress_bar_config(disable=a   )

         __lowerCamelCase          =  torch.Generator(device='''cpu'''   ).manual_seed(0   )
         __lowerCamelCase          =  pipeline(
             a  ,    generator=a  ,    output_type='''np'''  ,    )

         __lowerCamelCase          =  output.images[0]

         assert image.shape == (2_56, 2_56, 3)

         assert_mean_pixel_difference(a  ,    a  ,    15   )

'''simple docstring'''




import functools
import operator

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


__UpperCAmelCase												=logging.get_logger(__name__)

__UpperCAmelCase												={
    "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__				(       UpperCAmelCase__			):
     lowerCamelCase  :					List[Any]							="unispeech-sat"






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





         """simple docstring"""



         super().__init__(**a  ,    pad_token_id=a  ,    bos_token_id=a  ,    eos_token_id=a   )
         __lowerCamelCase          =  hidden_size
         __lowerCamelCase          =  feat_extract_norm
         __lowerCamelCase          =  feat_extract_activation
         __lowerCamelCase          =  list(a   )
         __lowerCamelCase          =  list(a   )
         __lowerCamelCase          =  list(a   )
         __lowerCamelCase          =  conv_bias
         __lowerCamelCase          =  num_conv_pos_embeddings
         __lowerCamelCase          =  num_conv_pos_embedding_groups
         __lowerCamelCase          =  len(self.conv_dim   )
         __lowerCamelCase          =  num_hidden_layers
         __lowerCamelCase          =  intermediate_size
         __lowerCamelCase          =  hidden_act
         __lowerCamelCase          =  num_attention_heads
         __lowerCamelCase          =  hidden_dropout
         __lowerCamelCase          =  attention_dropout
         __lowerCamelCase          =  activation_dropout
         __lowerCamelCase          =  feat_proj_dropout
         __lowerCamelCase          =  final_dropout
         __lowerCamelCase          =  layerdrop
         __lowerCamelCase          =  layer_norm_eps
         __lowerCamelCase          =  initializer_range
         __lowerCamelCase          =  vocab_size
         __lowerCamelCase          =  num_clusters
         __lowerCamelCase          =  do_stable_layer_norm
         __lowerCamelCase          =  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
         __lowerCamelCase          =  apply_spec_augment
         __lowerCamelCase          =  mask_time_prob
         __lowerCamelCase          =  mask_time_length
         __lowerCamelCase          =  mask_time_min_masks
         __lowerCamelCase          =  mask_feature_prob
         __lowerCamelCase          =  mask_feature_length
         __lowerCamelCase          =  mask_feature_min_masks

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

         # ctc loss
         __lowerCamelCase          =  ctc_loss_reduction
         __lowerCamelCase          =  ctc_zero_infinity

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

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






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Any   ):





         """simple docstring"""



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