
"""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 			lowerCAmelCase_		(a__				,      unittest.TestCase						):


				"""simple docstring"""



				__UpperCamelCase   :		str       =     UnCLIPImageVariationPipeline
				__UpperCamelCase   :		Union[str, Any]       =     IMAGE_VARIATION_PARAMS - {'''height''', '''width''', '''guidance_scale'''}
				__UpperCamelCase   :		Dict       =     IMAGE_VARIATION_BATCH_PARAMS

				__UpperCamelCase   :		List[str]       =     [
				    '''generator''',
				    '''return_dict''',
				    '''decoder_num_inference_steps''',
				    '''super_res_num_inference_steps''',
				]
				__UpperCamelCase   :		List[Any]       =     False



				@property
				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											return 32



				@property
				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											return 32



				@property
				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											return self.time_input_dim



				@property
				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											return self.time_input_dim * 4



				@property
				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											return 1_00



				@property
				def 			__magic_name__					(self					)      ->	Optional[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)
											return tokenizer



				@property
				def 			__magic_name__					(self					)      ->	Optional[Any]:



											"""simple docstring"""




											torch.manual_seed(0					)
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     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-05     , num_attention_heads=4     , num_hidden_layers=5     , pad_token_id=1     , vocab_size=10_00     , )
											return CLIPTextModelWithProjection(SCREAMING_SNAKE_CASE__					)



				@property
				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											torch.manual_seed(0					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     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(SCREAMING_SNAKE_CASE__					)



				@property
				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											torch.manual_seed(0					)

											SCREAMING_SNAKE_CASE__		: Any     =     {
											    """clip_embeddings_dim""": self.text_embedder_hidden_size,
											    """time_embed_dim""": self.time_embed_dim,
											    """cross_attention_dim""": self.cross_attention_dim,
											}

											SCREAMING_SNAKE_CASE__		: Any     =     UnCLIPTextProjModel(**SCREAMING_SNAKE_CASE__					)
											return model



				@property
				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											torch.manual_seed(0					)

											SCREAMING_SNAKE_CASE__		: Any     =     {
											    """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""",
											}

											SCREAMING_SNAKE_CASE__		: List[Any]     =     UNetaDConditionModel(**SCREAMING_SNAKE_CASE__					)
											return model



				@property
				def 			__magic_name__					(self					)      ->	str:



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



											"""simple docstring"""




											torch.manual_seed(0					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     UNetaDModel(**self.dummy_super_res_kwargs					)
											return model



				@property
				def 			__magic_name__					(self					)      ->	List[str]:



											"""simple docstring"""




											torch.manual_seed(1					)

											SCREAMING_SNAKE_CASE__		: int     =     UNetaDModel(**self.dummy_super_res_kwargs					)
											return model



				def 			__magic_name__					(self					)      ->	Optional[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     self.dummy_decoder
											SCREAMING_SNAKE_CASE__		: int     =     self.dummy_text_proj
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.dummy_text_encoder
											SCREAMING_SNAKE_CASE__		: Any     =     self.dummy_tokenizer
											SCREAMING_SNAKE_CASE__		: Dict     =     self.dummy_super_res_first
											SCREAMING_SNAKE_CASE__		: Dict     =     self.dummy_super_res_last

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     UnCLIPScheduler(
											    variance_type="""learned_range"""     , prediction_type="""epsilon"""     , num_train_timesteps=10_00     , )

											SCREAMING_SNAKE_CASE__		: Dict     =     UnCLIPScheduler(
											    variance_type="""fixed_small_log"""     , prediction_type="""epsilon"""     , num_train_timesteps=10_00     , )

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     CLIPImageProcessor(crop_size=32     , size=32					)

											SCREAMING_SNAKE_CASE__		: List[Any]     =     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 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__=0     , SCREAMING_SNAKE_CASE__=True					)      ->	Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     floats_tensor((1, 3, 32, 32)     , rng=random.Random(SCREAMING_SNAKE_CASE__					)					).to(SCREAMING_SNAKE_CASE__					)
											if str(SCREAMING_SNAKE_CASE__					).startswith("""mps"""					):
																		SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     torch.manual_seed(SCREAMING_SNAKE_CASE__					)
											else:
																		SCREAMING_SNAKE_CASE__		: int     =     torch.Generator(device=SCREAMING_SNAKE_CASE__					).manual_seed(SCREAMING_SNAKE_CASE__					)

											if pil_image:
																		SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     input_image * 0.5 + 0.5
																		SCREAMING_SNAKE_CASE__		: List[str]     =     input_image.clamp(0     , 1					)
																		SCREAMING_SNAKE_CASE__		: Optional[Any]     =     input_image.cpu().permute(0     , 2     , 3     , 1					).float().numpy()
																		SCREAMING_SNAKE_CASE__		: Tuple     =     DiffusionPipeline.numpy_to_pil(SCREAMING_SNAKE_CASE__					)[0]

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



				def 			__magic_name__					(self					)      ->	str:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: str     =     """cpu"""

											SCREAMING_SNAKE_CASE__		: str     =     self.get_dummy_components()

											SCREAMING_SNAKE_CASE__		: Tuple     =     self.pipeline_class(**SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     pipe.to(SCREAMING_SNAKE_CASE__					)

											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     , pil_image=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     pipe(**SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Any     =     output.images

											SCREAMING_SNAKE_CASE__		: List[str]     =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     , pil_image=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Any     =     pipe(
											    **SCREAMING_SNAKE_CASE__     , return_dict=SCREAMING_SNAKE_CASE__     , )[0]

											SCREAMING_SNAKE_CASE__		: List[str]     =     image[0, -3:, -3:, -1]
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     image_from_tuple[0, -3:, -3:, -1]

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

											SCREAMING_SNAKE_CASE__		: Dict     =     np.array(
											    [
											        0.9997,
											        0.0002,
											        0.9997,
											        0.9997,
											        0.9969,
											        0.0023,
											        0.9997,
											        0.9969,
											        0.9970,
											    ]					)

											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 			__magic_name__					(self					)      ->	Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     """cpu"""

											SCREAMING_SNAKE_CASE__		: List[Any]     =     self.get_dummy_components()

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     self.pipeline_class(**SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     pipe.to(SCREAMING_SNAKE_CASE__					)

											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     , pil_image=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Any     =     pipe(**SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Any     =     output.images

											SCREAMING_SNAKE_CASE__		: Tuple     =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     , pil_image=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: List[str]     =     pipe(
											    **SCREAMING_SNAKE_CASE__     , return_dict=SCREAMING_SNAKE_CASE__     , )[0]

											SCREAMING_SNAKE_CASE__		: List[Any]     =     image[0, -3:, -3:, -1]
											SCREAMING_SNAKE_CASE__		: List[Any]     =     image_from_tuple[0, -3:, -3:, -1]

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

											SCREAMING_SNAKE_CASE__		: int     =     np.array([0.9997, 0.0003, 0.9997, 0.9997, 0.9970, 0.0024, 0.9997, 0.9971, 0.9971]					)

											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 			__magic_name__					(self					)      ->	Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     """cpu"""

											SCREAMING_SNAKE_CASE__		: Tuple     =     self.get_dummy_components()

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     self.pipeline_class(**SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: str     =     pipe.to(SCREAMING_SNAKE_CASE__					)

											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     , pil_image=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Any     =     [
											    pipeline_inputs["""image"""],
											    pipeline_inputs["""image"""],
											]

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     pipe(**SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     output.images

											SCREAMING_SNAKE_CASE__		: int     =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     , pil_image=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     [
											    tuple_pipeline_inputs["""image"""],
											    tuple_pipeline_inputs["""image"""],
											]

											SCREAMING_SNAKE_CASE__		: List[str]     =     pipe(
											    **SCREAMING_SNAKE_CASE__     , return_dict=SCREAMING_SNAKE_CASE__     , )[0]

											SCREAMING_SNAKE_CASE__		: List[str]     =     image[0, -3:, -3:, -1]
											SCREAMING_SNAKE_CASE__		: List[str]     =     image_from_tuple[0, -3:, -3:, -1]

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

											SCREAMING_SNAKE_CASE__		: Tuple     =     np.array(
											    [
											        0.9997,
											        0.9989,
											        0.0008,
											        0.0021,
											        0.9960,
											        0.0018,
											        0.0014,
											        0.0002,
											        0.9933,
											    ]					)

											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 			__magic_name__					(self					)      ->	Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     torch.device("""cpu"""					)



											class 			lowerCAmelCase_		:


															"""simple docstring"""



															__UpperCamelCase   :		Any       =     1






											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.get_dummy_components()

											SCREAMING_SNAKE_CASE__		: Any     =     self.pipeline_class(**SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Any     =     pipe.to(SCREAMING_SNAKE_CASE__					)

											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: int     =     torch.Generator(device=SCREAMING_SNAKE_CASE__					).manual_seed(0					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     pipe.decoder.dtype
											SCREAMING_SNAKE_CASE__		: str     =     1

											SCREAMING_SNAKE_CASE__		: int     =     (
											    batch_size,
											    pipe.decoder.config.in_channels,
											    pipe.decoder.config.sample_size,
											    pipe.decoder.config.sample_size,
											)
											SCREAMING_SNAKE_CASE__		: Any     =     pipe.prepare_latents(
											    SCREAMING_SNAKE_CASE__     , dtype=SCREAMING_SNAKE_CASE__     , device=SCREAMING_SNAKE_CASE__     , generator=SCREAMING_SNAKE_CASE__     , latents=SCREAMING_SNAKE_CASE__     , scheduler=DummyScheduler()					)

											SCREAMING_SNAKE_CASE__		: Any     =     (
											    batch_size,
											    pipe.super_res_first.config.in_channels // 2,
											    pipe.super_res_first.config.sample_size,
											    pipe.super_res_first.config.sample_size,
											)
											SCREAMING_SNAKE_CASE__		: str     =     pipe.prepare_latents(
											    SCREAMING_SNAKE_CASE__     , dtype=SCREAMING_SNAKE_CASE__     , device=SCREAMING_SNAKE_CASE__     , generator=SCREAMING_SNAKE_CASE__     , latents=SCREAMING_SNAKE_CASE__     , scheduler=DummyScheduler()					)

											SCREAMING_SNAKE_CASE__		: str     =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     , pil_image=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: List[Any]     =     pipe(
											    **SCREAMING_SNAKE_CASE__     , decoder_latents=SCREAMING_SNAKE_CASE__     , super_res_latents=SCREAMING_SNAKE_CASE__					).images

											SCREAMING_SNAKE_CASE__		: int     =     self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     , pil_image=SCREAMING_SNAKE_CASE__					)
											# Don't pass image, instead pass embedding
											SCREAMING_SNAKE_CASE__		: List[str]     =     pipeline_inputs.pop("""image"""					)
											SCREAMING_SNAKE_CASE__		: Dict     =     pipe.image_encoder(SCREAMING_SNAKE_CASE__					).image_embeds

											SCREAMING_SNAKE_CASE__		: List[Any]     =     pipe(
											    **SCREAMING_SNAKE_CASE__     , decoder_latents=SCREAMING_SNAKE_CASE__     , super_res_latents=SCREAMING_SNAKE_CASE__     , image_embeddings=SCREAMING_SNAKE_CASE__     , ).images

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



				@skip_mps
				def 			__magic_name__					(self					)      ->	Optional[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     torch_device == """cpu"""

											# Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
											SCREAMING_SNAKE_CASE__		: Dict     =     1E-2

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



				@skip_mps
				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[Any]     =     torch_device == """cpu"""
											SCREAMING_SNAKE_CASE__		: List[Any]     =     True
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     [
											    """decoder_num_inference_steps""",
											    """super_res_num_inference_steps""",
											]

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



				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     [
											    """decoder_num_inference_steps""",
											    """super_res_num_inference_steps""",
											]

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



				@skip_mps
				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											return super().test_dict_tuple_outputs_equivalent()



				@skip_mps
				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											return super().test_save_load_local()



				@skip_mps
				def 			__magic_name__					(self					)      ->	Optional[Any]:



											"""simple docstring"""




											return super().test_save_load_optional_components()






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


				"""simple docstring"""



				def 			__magic_name__					(self					)      ->	Optional[Any]:



											"""simple docstring"""




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



				def 			__magic_name__					(self					)      ->	str:



											"""simple docstring"""




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

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     UnCLIPImageVariationPipeline.from_pretrained(
											    """kakaobrain/karlo-v1-alpha-image-variations"""     , torch_dtype=torch.floataa					)
											SCREAMING_SNAKE_CASE__		: int     =     pipeline.to(SCREAMING_SNAKE_CASE__					)
											pipeline.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Dict     =     torch.Generator(device="""cpu"""					).manual_seed(0					)
											SCREAMING_SNAKE_CASE__		: Any     =     pipeline(
											    SCREAMING_SNAKE_CASE__     , generator=SCREAMING_SNAKE_CASE__     , output_type="""np"""     , )

											SCREAMING_SNAKE_CASE__		: Dict     =     output.images[0]

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

											assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , 15					)






"""simple docstring"""




import functools
import operator

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


UpperCAmelCase__   :					str												=				logging.get_logger(__name__)

UpperCAmelCase__   :					Dict												=				{
    'microsoft/unispeech-large-1500h-cv': (
        'https://huggingface.co/microsoft/unispeech-large-1500h-cv/resolve/main/config.json'
    ),
    # See all UniSpeech models at https://huggingface.co/models?filter=unispeech
}



class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				__UpperCamelCase   :		List[str]       =     '''unispeech'''



				def __init__(self     , SCREAMING_SNAKE_CASE__=32     , SCREAMING_SNAKE_CASE__=7_68     , SCREAMING_SNAKE_CASE__=12     , SCREAMING_SNAKE_CASE__=12     , SCREAMING_SNAKE_CASE__=30_72     , SCREAMING_SNAKE_CASE__="gelu"     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=0.0     , SCREAMING_SNAKE_CASE__=0.0     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=0.02     , SCREAMING_SNAKE_CASE__=1E-5     , SCREAMING_SNAKE_CASE__="group"     , SCREAMING_SNAKE_CASE__="gelu"     , SCREAMING_SNAKE_CASE__=(5_12, 5_12, 5_12, 5_12, 5_12, 5_12, 5_12)     , SCREAMING_SNAKE_CASE__=(5, 2, 2, 2, 2, 2, 2)     , SCREAMING_SNAKE_CASE__=(10, 3, 3, 3, 3, 2, 2)     , SCREAMING_SNAKE_CASE__=False     , SCREAMING_SNAKE_CASE__=1_28     , SCREAMING_SNAKE_CASE__=16     , SCREAMING_SNAKE_CASE__=False     , SCREAMING_SNAKE_CASE__=True     , SCREAMING_SNAKE_CASE__=0.05     , SCREAMING_SNAKE_CASE__=10     , SCREAMING_SNAKE_CASE__=2     , SCREAMING_SNAKE_CASE__=0.0     , SCREAMING_SNAKE_CASE__=10     , SCREAMING_SNAKE_CASE__=0     , SCREAMING_SNAKE_CASE__=3_20     , SCREAMING_SNAKE_CASE__=2     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__=1_00     , SCREAMING_SNAKE_CASE__=2_56     , SCREAMING_SNAKE_CASE__=2_56     , SCREAMING_SNAKE_CASE__=0.1     , SCREAMING_SNAKE_CASE__="mean"     , SCREAMING_SNAKE_CASE__=False     , SCREAMING_SNAKE_CASE__=False     , SCREAMING_SNAKE_CASE__=2_56     , SCREAMING_SNAKE_CASE__=80     , SCREAMING_SNAKE_CASE__=0     , SCREAMING_SNAKE_CASE__=1     , SCREAMING_SNAKE_CASE__=2     , SCREAMING_SNAKE_CASE__=0.5     , **SCREAMING_SNAKE_CASE__     , )      ->	List[Any]:



											"""simple docstring"""




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

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

											# ctc loss
											SCREAMING_SNAKE_CASE__		: int     =     ctc_loss_reduction
											SCREAMING_SNAKE_CASE__		: str     =     ctc_zero_infinity

											# pretraining loss
											SCREAMING_SNAKE_CASE__		: List[str]     =     replace_prob



				@property
				def 			__magic_name__					(self					)      ->	Tuple:



											"""simple docstring"""




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




