


import functools
import operator

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


lowerCamelCase__							:						str							     =   logging.get_logger(__name__)

lowerCamelCase__							:						List[Any]							     =   {
    """facebook/wav2vec2-base-960h""": """https://huggingface.co/facebook/wav2vec2-base-960h/resolve/main/config.json""",
    # See all Wav2Vec2 models at https://huggingface.co/models?filter=wav2vec2
}
class 		__magic_name__						(snake_case_				):





     '''simple docstring'''



     __lowercase				:							int	   =       'wav2vec2'

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

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

       # ctc loss
       snake_case__						= ctc_loss_reduction
       snake_case__						= ctc_zero_infinity

       # adapter
       snake_case__						= add_adapter
       snake_case__						= adapter_kernel_size
       snake_case__						= adapter_stride
       snake_case__						= num_adapter_layers
       snake_case__						= output_hidden_size or hidden_size
       snake_case__						= adapter_attn_dim

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

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







     @property
     def 	SCREAMING_SNAKE_CASE__						(					self:Any   ):
       return functools.reduce(operator.mul     ,		self.conv_stride     ,		1   )








"""simple docstring"""





import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()






class    _lowerCAmelCase  (	a    ,  a    ,  a    ,  unittest.TestCase			):
       """simple docstring"""




       __magic_name__	:int						    =   StableUnCLIPPipeline
       __magic_name__	:int						    =   TEXT_TO_IMAGE_PARAMS
       __magic_name__	:List[str]						    =   TEXT_TO_IMAGE_BATCH_PARAMS
       __magic_name__	:Optional[int]						    =   TEXT_TO_IMAGE_IMAGE_PARAMS
       __magic_name__	:Union[str, Any]						    =   TEXT_TO_IMAGE_IMAGE_PARAMS

       # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
       __magic_name__	:List[str]						    =   False






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Dict											=				3_2
         lowerCAmelCase__     :List[Any]											=				embedder_hidden_size

         # prior components

         torch.manual_seed(0 )
         lowerCAmelCase__     :Any											=				CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

         torch.manual_seed(0 )
         lowerCAmelCase__     :Any											=				CLIPTextModelWithProjection(
             CLIPTextConfig(
                 bos_token_id=0       ,					eos_token_id=2       ,					hidden_size=__UpperCAmelCase       ,					projection_dim=__UpperCAmelCase       ,					intermediate_size=3_7       ,					layer_norm_eps=1E-05       ,					num_attention_heads=4       ,					num_hidden_layers=5       ,					pad_token_id=1       ,					vocab_size=1_0_0_0       ,					) )

         torch.manual_seed(0 )
         lowerCAmelCase__     :int											=				PriorTransformer(
             num_attention_heads=2       ,					attention_head_dim=1_2       ,					embedding_dim=__UpperCAmelCase       ,					num_layers=1       ,					)

         torch.manual_seed(0 )
         lowerCAmelCase__     :Optional[int]											=				DDPMScheduler(
             variance_type='fixed_small_log'       ,					prediction_type='sample'       ,					num_train_timesteps=1_0_0_0       ,					clip_sample=__UpperCAmelCase       ,					clip_sample_range=5.0       ,					beta_schedule='squaredcos_cap_v2'       ,					)

         # regular denoising components

         torch.manual_seed(0 )
         lowerCAmelCase__     :Dict											=				StableUnCLIPImageNormalizer(embedding_dim=__UpperCAmelCase )
         lowerCAmelCase__     :List[Any]											=				DDPMScheduler(beta_schedule='squaredcos_cap_v2' )

         torch.manual_seed(0 )
         lowerCAmelCase__     :List[Any]											=				CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' )

         torch.manual_seed(0 )
         lowerCAmelCase__     :str											=				CLIPTextModel(
             CLIPTextConfig(
                 bos_token_id=0       ,					eos_token_id=2       ,					hidden_size=__UpperCAmelCase       ,					projection_dim=3_2       ,					intermediate_size=3_7       ,					layer_norm_eps=1E-05       ,					num_attention_heads=4       ,					num_hidden_layers=5       ,					pad_token_id=1       ,					vocab_size=1_0_0_0       ,					) )

         torch.manual_seed(0 )
         lowerCAmelCase__     :Optional[int]											=				UNetaDConditionModel(
             sample_size=3_2       ,					in_channels=4       ,					out_channels=4       ,					down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')       ,					up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')       ,					block_out_channels=(3_2, 6_4)       ,					attention_head_dim=(2, 4)       ,					class_embed_type='projection'       ,					projection_class_embeddings_input_dim=embedder_projection_dim * 2       ,					cross_attention_dim=__UpperCAmelCase       ,					layers_per_block=1       ,					upcast_attention=__UpperCAmelCase       ,					use_linear_projection=__UpperCAmelCase       ,					)

         torch.manual_seed(0 )
         lowerCAmelCase__     :Tuple											=				DDIMScheduler(
             beta_schedule='scaled_linear'       ,					beta_start=0.0_00_85       ,					beta_end=0.0_12       ,					prediction_type='v_prediction'       ,					set_alpha_to_one=__UpperCAmelCase       ,					steps_offset=1       ,					)

         torch.manual_seed(0 )
         lowerCAmelCase__     :Optional[int]											=				AutoencoderKL()

         lowerCAmelCase__     :Optional[int]											=				{
             # prior components
             'prior_tokenizer': prior_tokenizer,
             'prior_text_encoder': prior_text_encoder,
             'prior': prior,
             'prior_scheduler': prior_scheduler,
             # image noising components
             'image_normalizer': image_normalizer,
             'image_noising_scheduler': image_noising_scheduler,
             # regular denoising components
             'tokenizer': tokenizer,
             'text_encoder': text_encoder,
             'unet': unet,
             'scheduler': scheduler,
             'vae': vae,
         }

         return components






       def 	snake_case		(       self       ,					__UpperCAmelCase       ,					__UpperCAmelCase=0 ):



         '''simple docstring'''

         if str(__UpperCAmelCase ).startswith('mps' ):
           lowerCAmelCase__     :str											=				torch.manual_seed(__UpperCAmelCase )
         else:
           lowerCAmelCase__     :Optional[int]											=				torch.Generator(device=__UpperCAmelCase ).manual_seed(__UpperCAmelCase )
         lowerCAmelCase__     :Tuple											=				{
             'prompt': 'A painting of a squirrel eating a burger',
             'generator': generator,
             'num_inference_steps': 2,
             'prior_num_inference_steps': 2,
             'output_type': 'numpy',
         }
         return inputs






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Optional[int]											=				torch_device == 'cpu'

         self._test_attention_slicing_forward_pass(test_max_difference=__UpperCAmelCase )






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :str											=				torch_device in ['cpu', 'mps']

         self._test_inference_batch_single_identical(test_max_difference=__UpperCAmelCase )






@slow
@require_torch_gpu
class    _lowerCAmelCase  (	unittest.TestCase			):
       """simple docstring"""




       def 	snake_case		(       self ):



         '''simple docstring'''

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






       def 	snake_case		(       self ):



         '''simple docstring'''

         lowerCAmelCase__     :Tuple											=				load_numpy(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy' )

         lowerCAmelCase__     :List[Any]											=				StableUnCLIPPipeline.from_pretrained('fusing/stable-unclip-2-1-l'       ,					torch_dtype=torch.floataa )
         pipe.to(__UpperCAmelCase )
         pipe.set_progress_bar_config(disable=__UpperCAmelCase )
         # stable unclip will oom when integration tests are run on a V100,
         # so turn on memory savings
         pipe.enable_attention_slicing()
         pipe.enable_sequential_cpu_offload()

         lowerCAmelCase__     :List[str]											=				torch.Generator(device='cpu' ).manual_seed(0 )
         lowerCAmelCase__     :List[str]											=				pipe('anime turle'       ,					generator=__UpperCAmelCase       ,					output_type='np' )

         lowerCAmelCase__     :Union[str, Any]											=				output.images[0]

         assert image.shape == (7_6_8, 7_6_8, 3)

         assert_mean_pixel_difference(__UpperCAmelCase       ,					__UpperCAmelCase )






       def 	snake_case		(       self ):



         '''simple docstring'''

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

         lowerCAmelCase__     :int											=				StableUnCLIPPipeline.from_pretrained('fusing/stable-unclip-2-1-l'       ,					torch_dtype=torch.floataa )
         lowerCAmelCase__     :List[str]											=				pipe.to(__UpperCAmelCase )
         pipe.set_progress_bar_config(disable=__UpperCAmelCase )
         pipe.enable_attention_slicing()
         pipe.enable_sequential_cpu_offload()

         lowerCAmelCase__     :Tuple											=				pipe(
             'anime turtle'       ,					prior_num_inference_steps=2       ,					num_inference_steps=2       ,					output_type='np'       ,					)

         lowerCAmelCase__     :str											=				torch.cuda.max_memory_allocated()
         # make sure that less than 7 GB is allocated
         assert mem_bytes < 7 * 1_0**9
