




"""simple docstring"""






import argparse

import torch

from transformers import (
    EncodecConfig,
    EncodecFeatureExtractor,
    EncodecModel,
    logging,
)


# checkpoints downloaded from:
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_24khz-d7cc33bc.th
# https://huggingface.co/facebook/musicgen-small/resolve/main/compression_state_dict.bin
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_48khz-7e698e3e.th


logging.set_verbosity_info()
UpperCamelCase__						=			logging.get_logger('''transformers.models.encodec''')

UpperCamelCase__						=			{
    '''quantizer.vq.layers.*._codebook.inited''': '''quantizer.layers.*.codebook.inited''',
    '''quantizer.vq.layers.*._codebook.cluster_size''': '''quantizer.layers.*.codebook.cluster_size''',
    '''quantizer.vq.layers.*._codebook.embed''': '''quantizer.layers.*.codebook.embed''',
    '''quantizer.vq.layers.*._codebook.embed_avg''': '''quantizer.layers.*.codebook.embed_avg''',
}
UpperCamelCase__						=			{
    '''encoder.model.0.conv.conv''': '''encoder.layers.0.conv''',
    '''encoder.model.1.block.1.conv.conv''': '''encoder.layers.1.block.1.conv''',
    '''encoder.model.1.block.3.conv.conv''': '''encoder.layers.1.block.3.conv''',
    '''encoder.model.1.shortcut.conv.conv''': '''encoder.layers.1.shortcut.conv''',
    '''encoder.model.3.conv.conv''': '''encoder.layers.3.conv''',
    '''encoder.model.4.block.1.conv.conv''': '''encoder.layers.4.block.1.conv''',
    '''encoder.model.4.block.3.conv.conv''': '''encoder.layers.4.block.3.conv''',
    '''encoder.model.4.shortcut.conv.conv''': '''encoder.layers.4.shortcut.conv''',
    '''encoder.model.6.conv.conv''': '''encoder.layers.6.conv''',
    '''encoder.model.7.block.1.conv.conv''': '''encoder.layers.7.block.1.conv''',
    '''encoder.model.7.block.3.conv.conv''': '''encoder.layers.7.block.3.conv''',
    '''encoder.model.7.shortcut.conv.conv''': '''encoder.layers.7.shortcut.conv''',
    '''encoder.model.9.conv.conv''': '''encoder.layers.9.conv''',
    '''encoder.model.10.block.1.conv.conv''': '''encoder.layers.10.block.1.conv''',
    '''encoder.model.10.block.3.conv.conv''': '''encoder.layers.10.block.3.conv''',
    '''encoder.model.10.shortcut.conv.conv''': '''encoder.layers.10.shortcut.conv''',
    '''encoder.model.12.conv.conv''': '''encoder.layers.12.conv''',
    '''encoder.model.13.lstm''': '''encoder.layers.13.lstm''',
    '''encoder.model.15.conv.conv''': '''encoder.layers.15.conv''',
}
UpperCamelCase__						=			{
    '''encoder.model.0.conv.norm''': '''encoder.layers.0.norm''',
    '''encoder.model.1.block.1.conv.norm''': '''encoder.layers.1.block.1.norm''',
    '''encoder.model.1.block.3.conv.norm''': '''encoder.layers.1.block.3.norm''',
    '''encoder.model.1.shortcut.conv.norm''': '''encoder.layers.1.shortcut.norm''',
    '''encoder.model.3.conv.norm''': '''encoder.layers.3.norm''',
    '''encoder.model.4.block.1.conv.norm''': '''encoder.layers.4.block.1.norm''',
    '''encoder.model.4.block.3.conv.norm''': '''encoder.layers.4.block.3.norm''',
    '''encoder.model.4.shortcut.conv.norm''': '''encoder.layers.4.shortcut.norm''',
    '''encoder.model.6.conv.norm''': '''encoder.layers.6.norm''',
    '''encoder.model.7.block.1.conv.norm''': '''encoder.layers.7.block.1.norm''',
    '''encoder.model.7.block.3.conv.norm''': '''encoder.layers.7.block.3.norm''',
    '''encoder.model.7.shortcut.conv.norm''': '''encoder.layers.7.shortcut.norm''',
    '''encoder.model.9.conv.norm''': '''encoder.layers.9.norm''',
    '''encoder.model.10.block.1.conv.norm''': '''encoder.layers.10.block.1.norm''',
    '''encoder.model.10.block.3.conv.norm''': '''encoder.layers.10.block.3.norm''',
    '''encoder.model.10.shortcut.conv.norm''': '''encoder.layers.10.shortcut.norm''',
    '''encoder.model.12.conv.norm''': '''encoder.layers.12.norm''',
    '''encoder.model.15.conv.norm''': '''encoder.layers.15.norm''',
}
UpperCamelCase__						=			{
    '''decoder.model.0.conv.conv''': '''decoder.layers.0.conv''',
    '''decoder.model.1.lstm''': '''decoder.layers.1.lstm''',
    '''decoder.model.3.convtr.convtr''': '''decoder.layers.3.conv''',
    '''decoder.model.4.block.1.conv.conv''': '''decoder.layers.4.block.1.conv''',
    '''decoder.model.4.block.3.conv.conv''': '''decoder.layers.4.block.3.conv''',
    '''decoder.model.4.shortcut.conv.conv''': '''decoder.layers.4.shortcut.conv''',
    '''decoder.model.6.convtr.convtr''': '''decoder.layers.6.conv''',
    '''decoder.model.7.block.1.conv.conv''': '''decoder.layers.7.block.1.conv''',
    '''decoder.model.7.block.3.conv.conv''': '''decoder.layers.7.block.3.conv''',
    '''decoder.model.7.shortcut.conv.conv''': '''decoder.layers.7.shortcut.conv''',
    '''decoder.model.9.convtr.convtr''': '''decoder.layers.9.conv''',
    '''decoder.model.10.block.1.conv.conv''': '''decoder.layers.10.block.1.conv''',
    '''decoder.model.10.block.3.conv.conv''': '''decoder.layers.10.block.3.conv''',
    '''decoder.model.10.shortcut.conv.conv''': '''decoder.layers.10.shortcut.conv''',
    '''decoder.model.12.convtr.convtr''': '''decoder.layers.12.conv''',
    '''decoder.model.13.block.1.conv.conv''': '''decoder.layers.13.block.1.conv''',
    '''decoder.model.13.block.3.conv.conv''': '''decoder.layers.13.block.3.conv''',
    '''decoder.model.13.shortcut.conv.conv''': '''decoder.layers.13.shortcut.conv''',
    '''decoder.model.15.conv.conv''': '''decoder.layers.15.conv''',
}
UpperCamelCase__						=			{
    '''decoder.model.0.conv.norm''': '''decoder.layers.0.norm''',
    '''decoder.model.3.convtr.norm''': '''decoder.layers.3.norm''',
    '''decoder.model.4.block.1.conv.norm''': '''decoder.layers.4.block.1.norm''',
    '''decoder.model.4.block.3.conv.norm''': '''decoder.layers.4.block.3.norm''',
    '''decoder.model.4.shortcut.conv.norm''': '''decoder.layers.4.shortcut.norm''',
    '''decoder.model.6.convtr.norm''': '''decoder.layers.6.norm''',
    '''decoder.model.7.block.1.conv.norm''': '''decoder.layers.7.block.1.norm''',
    '''decoder.model.7.block.3.conv.norm''': '''decoder.layers.7.block.3.norm''',
    '''decoder.model.7.shortcut.conv.norm''': '''decoder.layers.7.shortcut.norm''',
    '''decoder.model.9.convtr.norm''': '''decoder.layers.9.norm''',
    '''decoder.model.10.block.1.conv.norm''': '''decoder.layers.10.block.1.norm''',
    '''decoder.model.10.block.3.conv.norm''': '''decoder.layers.10.block.3.norm''',
    '''decoder.model.10.shortcut.conv.norm''': '''decoder.layers.10.shortcut.norm''',
    '''decoder.model.12.convtr.norm''': '''decoder.layers.12.norm''',
    '''decoder.model.13.block.1.conv.norm''': '''decoder.layers.13.block.1.norm''',
    '''decoder.model.13.block.3.conv.norm''': '''decoder.layers.13.block.3.norm''',
    '''decoder.model.13.shortcut.conv.norm''': '''decoder.layers.13.shortcut.norm''',
    '''decoder.model.15.conv.norm''': '''decoder.layers.15.norm''',
}
UpperCamelCase__						=			{
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
}
UpperCamelCase__						=			{
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_ENCODER_48K,
    **MAPPING_DECODER,
    **MAPPING_DECODER_48K,
}
UpperCamelCase__						=			[]
UpperCamelCase__						=			[]





def 							UpperCAmelCase		(		snake_case			:					int      ,       snake_case			:					Tuple      ,       snake_case			:					Optional[Any]      ,       snake_case			:					List[str]      ,       snake_case			:					int    ):
					for attribute in key.split('''.'''    ):
										_lowerCAmelCase:str									=  getattr(snake_case      ,       snake_case    )

					if weight_type is not None:
										_lowerCAmelCase:str									=  getattr(snake_case      ,       snake_case    ).shape
					else:
										_lowerCAmelCase:Any									=  hf_pointer.shape

					if hf_shape != value.shape:
										raise ValueError(
										    F'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'
										    F' {value.shape} for {full_name}'    )

					if weight_type == "weight":
										_lowerCAmelCase:Tuple									=  value
					elif weight_type == "weight_g":
										_lowerCAmelCase:int									=  value
					elif weight_type == "weight_v":
										_lowerCAmelCase:Optional[int]									=  value
					elif weight_type == "bias":
										_lowerCAmelCase:Optional[Any]									=  value
					elif weight_type == "running_mean":
										_lowerCAmelCase:Optional[Any]									=  value
					elif weight_type == "running_var":
										_lowerCAmelCase:List[str]									=  value
					elif weight_type == "num_batches_tracked":
										_lowerCAmelCase:Optional[int]									=  value
					elif weight_type == "weight_ih_l0":
										_lowerCAmelCase:Optional[int]									=  value
					elif weight_type == "weight_hh_l0":
										_lowerCAmelCase:Optional[Any]									=  value
					elif weight_type == "bias_ih_l0":
										_lowerCAmelCase:str									=  value
					elif weight_type == "bias_hh_l0":
										_lowerCAmelCase:Optional[Any]									=  value
					elif weight_type == "weight_ih_l1":
										_lowerCAmelCase:List[Any]									=  value
					elif weight_type == "weight_hh_l1":
										_lowerCAmelCase:int									=  value
					elif weight_type == "bias_ih_l1":
										_lowerCAmelCase:List[str]									=  value
					elif weight_type == "bias_hh_l1":
										_lowerCAmelCase:Dict									=  value
					else:
										_lowerCAmelCase:Optional[Any]									=  value

					logger.info(F'{key + ("." + weight_type if weight_type is not None else "")} was initialized from {full_name}.'    )





def 							UpperCAmelCase		(		snake_case			:					Optional[Any]      ,       snake_case			:					Optional[int]    ):
					for key in ignore_keys:
										if key.endswith('''.*'''    ):
															if name.startswith(key[:-1]    ):
																				return True
										elif ".*." in key:
															_lowerCAmelCase							,   _lowerCAmelCase:Any									=  key.split('''.*.'''    )
															if prefix in name and suffix in name:
																				return True
										elif key in name:
															return True
					return False





def 							UpperCAmelCase		(		snake_case			:					Optional[Any]      ,       snake_case			:					Any      ,       snake_case			:					Tuple    ):
					_lowerCAmelCase:str									=  []

					if model_name == "encodec_24khz" or "encodec_32khz":
										_lowerCAmelCase:Dict									=  MAPPING_24K
					elif model_name == "encodec_48khz":
										_lowerCAmelCase:Optional[Any]									=  MAPPING_48K
					else:
										raise ValueError(F'Unsupported model: {model_name}'    )

					for name, value in orig_dict.items():
										if should_ignore(snake_case      ,       snake_case    ):
															logger.info(F'{name} was ignored'    )
															continue

										_lowerCAmelCase:List[str]									=  False
										for key, mapped_key in MAPPING.items():
															if "*" in key:
																				_lowerCAmelCase							,   _lowerCAmelCase:List[Any]									=  key.split('''.*.'''    )
																				if prefix in name and suffix in name:
																									_lowerCAmelCase:Dict									=  suffix

															if key in name:
																				# HACK otherwise .embed gets initialized with .embed_avg too
																				if key.endswith('''embed'''    ) and name.endswith('''embed_avg'''    ):
																									continue

																				_lowerCAmelCase:Union[str, Any]									=  True
																				if "*" in mapped_key:
																									_lowerCAmelCase:str									=  name.split(snake_case    )[0].split('''.'''    )[-2]
																									_lowerCAmelCase:int									=  mapped_key.replace('''*'''      ,       snake_case    )
																				if "weight_g" in name:
																									_lowerCAmelCase:str									=  '''weight_g'''
																				elif "weight_v" in name:
																									_lowerCAmelCase:Any									=  '''weight_v'''
																				elif "weight_ih_l0" in name:
																									_lowerCAmelCase:Dict									=  '''weight_ih_l0'''
																				elif "weight_hh_l0" in name:
																									_lowerCAmelCase:Dict									=  '''weight_hh_l0'''
																				elif "bias_ih_l0" in name:
																									_lowerCAmelCase:Any									=  '''bias_ih_l0'''
																				elif "bias_hh_l0" in name:
																									_lowerCAmelCase:Union[str, Any]									=  '''bias_hh_l0'''
																				elif "weight_ih_l1" in name:
																									_lowerCAmelCase:Optional[Any]									=  '''weight_ih_l1'''
																				elif "weight_hh_l1" in name:
																									_lowerCAmelCase:Dict									=  '''weight_hh_l1'''
																				elif "bias_ih_l1" in name:
																									_lowerCAmelCase:List[str]									=  '''bias_ih_l1'''
																				elif "bias_hh_l1" in name:
																									_lowerCAmelCase:Any									=  '''bias_hh_l1'''
																				elif "bias" in name:
																									_lowerCAmelCase:Any									=  '''bias'''
																				elif "weight" in name:
																									_lowerCAmelCase:int									=  '''weight'''
																				elif "running_mean" in name:
																									_lowerCAmelCase:Any									=  '''running_mean'''
																				elif "running_var" in name:
																									_lowerCAmelCase:str									=  '''running_var'''
																				elif "num_batches_tracked" in name:
																									_lowerCAmelCase:Dict									=  '''num_batches_tracked'''
																				else:
																									_lowerCAmelCase:int									=  None
																				set_recursively(snake_case      ,       snake_case      ,       snake_case      ,       snake_case      ,       snake_case    )
															continue
										if not is_used:
															unused_weights.append(snake_case    )

					logger.warning(F'Unused weights: {unused_weights}'    )





@torch.no_grad()
def 							UpperCAmelCase		(		snake_case			:					List[str]      ,       snake_case			:					List[Any]      ,       snake_case			:					Optional[Any]      ,       snake_case			:					Tuple=None      ,       snake_case			:					str=None      ,       ):
					if config_path is not None:
										_lowerCAmelCase:Union[str, Any]									=  EncodecConfig.from_pretrained(snake_case    )
					else:
										_lowerCAmelCase:str									=  EncodecConfig()

					if model_name == "encodec_24khz":
										pass  # config is already correct
					elif model_name == "encodec_32khz":
										_lowerCAmelCase:Optional[Any]									=  [8, 5, 4, 4]
										_lowerCAmelCase:int									=  [2.2]
										_lowerCAmelCase:Any									=  64
										_lowerCAmelCase:Tuple									=  32000
										_lowerCAmelCase:Tuple									=  2048
										_lowerCAmelCase:int									=  False
										_lowerCAmelCase:Any									=  False
										_lowerCAmelCase:Tuple									=  False
					elif model_name == "encodec_48khz":
										_lowerCAmelCase:Union[str, Any]									=  [8, 5, 4, 2]
										_lowerCAmelCase:Optional[Any]									=  [3.0, 6.0, 12.0, 24.0]
										_lowerCAmelCase:Dict									=  48000
										_lowerCAmelCase:List[str]									=  2
										_lowerCAmelCase:Dict									=  False
										_lowerCAmelCase:Optional[Any]									=  '''time_group_norm'''
										_lowerCAmelCase:Dict									=  True
										_lowerCAmelCase:Tuple									=  1.0
										_lowerCAmelCase:Dict									=  0.01
					else:
										raise ValueError(F'Unknown model name: {model_name}'    )

					_lowerCAmelCase:Optional[Any]									=  EncodecModel(snake_case    )

					_lowerCAmelCase:List[str]									=  EncodecFeatureExtractor(
					    feature_size=config.audio_channels      ,       sampling_rate=config.sampling_rate      ,       chunk_length_s=config.chunk_length_s      ,       overlap=config.overlap      ,       )
					feature_extractor.save_pretrained(snake_case    )

					_lowerCAmelCase:int									=  torch.load(snake_case    )
					if "best_state" in original_checkpoint:
										# we might have a training state saved, in which case discard the yaml results and just retain the weights
										_lowerCAmelCase:List[str]									=  original_checkpoint['''best_state''']
					recursively_load_weights(snake_case      ,       snake_case      ,       snake_case    )
					model.save_pretrained(snake_case    )

					if repo_id:
										print('''Pushing to the hub...'''    )
										feature_extractor.push_to_hub(snake_case    )
										model.push_to_hub(snake_case    )


if __name__ == "__main__":
				UpperCamelCase__						=			argparse.ArgumentParser()
				parser.add_argument(
				    '''--model''',
				    default='''encodec_24khz''',
				    type=str,
				    help='''The model to convert. Should be one of \'encodec_24khz\', \'encodec_32khz\', \'encodec_48khz\'.''',
				)
				parser.add_argument('''--checkpoint_path''', required=True, default=None, type=str, help='''Path to original checkpoint''')
				parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
				parser.add_argument(
				    '''--pytorch_dump_folder_path''', required=True, default=None, type=str, help='''Path to the output PyTorch model.'''
				)
				parser.add_argument(
				    '''--push_to_hub''', default=None, type=str, help='''Where to upload the converted model on the 🤗 hub.'''
				)

				UpperCamelCase__						=			parser.parse_args()
				convert_checkpoint(
				    args.model,
				    args.checkpoint_path,
				    args.pytorch_dump_folder_path,
				    args.config_path,
				    args.push_to_hub,
				)












"""simple docstring"""






import gc
import unittest

import numpy as np
import torch
import torch.nn.functional as F
from transformers import (
    ClapTextConfig,
    ClapTextModelWithProjection,
    RobertaTokenizer,
    SpeechTaHifiGan,
    SpeechTaHifiGanConfig,
)

from diffusers import (
    AudioLDMPipeline,
    AutoencoderKL,
    DDIMScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_AUDIO_BATCH_PARAMS, TEXT_TO_AUDIO_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()




class   a__			(       UpperCamelCase_					,	unittest.TestCase  ):
						snake_case__             = AudioLDMPipeline
						snake_case__             = TEXT_TO_AUDIO_PARAMS
						snake_case__             = TEXT_TO_AUDIO_BATCH_PARAMS
						snake_case__             = frozenset(
						    [
						        '''num_inference_steps''',
						        '''num_waveforms_per_prompt''',
						        '''generator''',
						        '''latents''',
						        '''output_type''',
						        '''return_dict''',
						        '''callback''',
						        '''callback_steps''',
						    ]  )





						def       __UpperCamelCase     (							self      :	int)						->       Any:




											"""simple docstring"""







											torch.manual_seed(0)
											_lowerCAmelCase:int									=  UNetaDConditionModel(
											    block_out_channels=(32, 64)     ,layers_per_block=2     ,sample_size=32     ,in_channels=4     ,out_channels=4     ,down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')     ,up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')     ,cross_attention_dim=(32, 64)     ,class_embed_type='''simple_projection'''     ,projection_class_embeddings_input_dim=32     ,class_embeddings_concat=a__     ,)
											_lowerCAmelCase:Optional[int]									=  DDIMScheduler(
											    beta_start=0.00085     ,beta_end=0.012     ,beta_schedule='''scaled_linear'''     ,clip_sample=a__     ,set_alpha_to_one=a__     ,)
											torch.manual_seed(0)
											_lowerCAmelCase:Optional[Any]									=  AutoencoderKL(
											    block_out_channels=[32, 64]     ,in_channels=1     ,out_channels=1     ,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']     ,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']     ,latent_channels=4     ,)
											torch.manual_seed(0)
											_lowerCAmelCase:Dict									=  ClapTextConfig(
											    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     ,projection_dim=32     ,)
											_lowerCAmelCase:str									=  ClapTextModelWithProjection(a__)
											_lowerCAmelCase:Dict									=  RobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-random-roberta'''     ,model_max_length=77)

											_lowerCAmelCase:Union[str, Any]									=  SpeechTaHifiGanConfig(
											    model_in_dim=8     ,sampling_rate=1_6000     ,upsample_initial_channel=16     ,upsample_rates=[2, 2]     ,upsample_kernel_sizes=[4, 4]     ,resblock_kernel_sizes=[3, 7]     ,resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5]]     ,normalize_before=a__     ,)

											_lowerCAmelCase:List[Any]									=  SpeechTaHifiGan(a__)

											_lowerCAmelCase:Optional[Any]									=  {
											    '''unet''': unet,
											    '''scheduler''': scheduler,
											    '''vae''': vae,
											    '''text_encoder''': text_encoder,
											    '''tokenizer''': tokenizer,
											    '''vocoder''': vocoder,
											}
											return components





						def       __UpperCamelCase     (							self      :	List[Any]     ,a__      :	int     ,a__      :	Tuple=0)						->       Optional[int]:




											"""simple docstring"""







											if str(a__).startswith('''mps'''):
																_lowerCAmelCase:Tuple									=  torch.manual_seed(a__)
											else:
																_lowerCAmelCase:Dict									=  torch.Generator(device=a__).manual_seed(a__)
											_lowerCAmelCase:Tuple									=  {
											    '''prompt''': '''A hammer hitting a wooden surface''',
											    '''generator''': generator,
											    '''num_inference_steps''': 2,
											    '''guidance_scale''': 6.0,
											}
											return inputs





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




											"""simple docstring"""







											_lowerCAmelCase:str									=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator

											_lowerCAmelCase:Dict									=  self.get_dummy_components()
											_lowerCAmelCase:List[str]									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:Optional[int]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:str									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Optional[Any]									=  audioldm_pipe(**a__)
											_lowerCAmelCase:List[str]									=  output.audios[0]

											assert audio.ndim == 1
											assert len(a__) == 256

											_lowerCAmelCase:List[str]									=  audio[:10]
											_lowerCAmelCase:Dict									=  np.array(
											    [-0.0050, 0.0050, -0.0060, 0.0033, -0.0026, 0.0033, -0.0027, 0.0033, -0.0028, 0.0033])

											assert np.abs(audio_slice - expected_slice).max() < 1E-2





						def       __UpperCamelCase     (							self      :	Tuple)						->       Tuple:




											"""simple docstring"""







											_lowerCAmelCase:int									=  self.get_dummy_components()
											_lowerCAmelCase:Optional[Any]									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:Union[str, Any]									=  audioldm_pipe.to(a__)
											_lowerCAmelCase:Any									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Dict									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:List[Any]									=  3 * [inputs['''prompt''']]

											# forward
											_lowerCAmelCase:Dict									=  audioldm_pipe(**a__)
											_lowerCAmelCase:Union[str, Any]									=  output.audios[0]

											_lowerCAmelCase:Tuple									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Optional[Any]									=  3 * [inputs.pop('''prompt''')]

											_lowerCAmelCase:Tuple									=  audioldm_pipe.tokenizer(
											    a__     ,padding='''max_length'''     ,max_length=audioldm_pipe.tokenizer.model_max_length     ,truncation=a__     ,return_tensors='''pt'''     ,)
											_lowerCAmelCase:Optional[int]									=  text_inputs['''input_ids'''].to(a__)

											_lowerCAmelCase:List[Any]									=  audioldm_pipe.text_encoder(
											    a__     ,)
											_lowerCAmelCase:int									=  prompt_embeds.text_embeds
											# additional L_2 normalization over each hidden-state
											_lowerCAmelCase:List[Any]									=  F.normalize(a__     ,dim=-1)

											_lowerCAmelCase:int									=  prompt_embeds

											# forward
											_lowerCAmelCase:Tuple									=  audioldm_pipe(**a__)
											_lowerCAmelCase:Dict									=  output.audios[0]

											assert np.abs(audio_a - audio_a).max() < 1E-2





						def       __UpperCamelCase     (							self      :	Union[str, Any])						->       List[str]:




											"""simple docstring"""







											_lowerCAmelCase:Any									=  self.get_dummy_components()
											_lowerCAmelCase:str									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:int									=  audioldm_pipe.to(a__)
											_lowerCAmelCase:Any									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Any									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Tuple									=  3 * ['''this is a negative prompt''']
											_lowerCAmelCase:str									=  negative_prompt
											_lowerCAmelCase:List[Any]									=  3 * [inputs['''prompt''']]

											# forward
											_lowerCAmelCase:Optional[Any]									=  audioldm_pipe(**a__)
											_lowerCAmelCase:Any									=  output.audios[0]

											_lowerCAmelCase:Tuple									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Tuple									=  3 * [inputs.pop('''prompt''')]

											_lowerCAmelCase:Tuple									=  []
											for p in [prompt, negative_prompt]:
																_lowerCAmelCase:str									=  audioldm_pipe.tokenizer(
																    a__     ,padding='''max_length'''     ,max_length=audioldm_pipe.tokenizer.model_max_length     ,truncation=a__     ,return_tensors='''pt'''     ,)
																_lowerCAmelCase:Dict									=  text_inputs['''input_ids'''].to(a__)

																_lowerCAmelCase:int									=  audioldm_pipe.text_encoder(
																    a__     ,)
																_lowerCAmelCase:List[Any]									=  text_embeds.text_embeds
																# additional L_2 normalization over each hidden-state
																_lowerCAmelCase:List[str]									=  F.normalize(a__     ,dim=-1)

																embeds.append(a__)

											_lowerCAmelCase							,   _lowerCAmelCase:Optional[Any]									=  embeds

											# forward
											_lowerCAmelCase:List[str]									=  audioldm_pipe(**a__)
											_lowerCAmelCase:int									=  output.audios[0]

											assert np.abs(audio_a - audio_a).max() < 1E-2





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




											"""simple docstring"""







											_lowerCAmelCase:Tuple									=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
											_lowerCAmelCase:Union[str, Any]									=  self.get_dummy_components()
											_lowerCAmelCase:Union[str, Any]									=  PNDMScheduler(skip_prk_steps=a__)
											_lowerCAmelCase:Union[str, Any]									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:List[str]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Tuple									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:int									=  '''egg cracking'''
											_lowerCAmelCase:Union[str, Any]									=  audioldm_pipe(**a__     ,negative_prompt=a__)
											_lowerCAmelCase:Dict									=  output.audios[0]

											assert audio.ndim == 1
											assert len(a__) == 256

											_lowerCAmelCase:Optional[int]									=  audio[:10]
											_lowerCAmelCase:Optional[Any]									=  np.array(
											    [-0.0051, 0.0050, -0.0060, 0.0034, -0.0026, 0.0033, -0.0027, 0.0033, -0.0028, 0.0032])

											assert np.abs(audio_slice - expected_slice).max() < 1E-2





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




											"""simple docstring"""







											_lowerCAmelCase:Optional[int]									=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
											_lowerCAmelCase:Optional[int]									=  self.get_dummy_components()
											_lowerCAmelCase:str									=  PNDMScheduler(skip_prk_steps=a__)
											_lowerCAmelCase:Any									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:List[str]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Tuple									=  '''A hammer hitting a wooden surface'''

											# test num_waveforms_per_prompt=1 (default)
											_lowerCAmelCase:str									=  audioldm_pipe(a__     ,num_inference_steps=2).audios

											assert audios.shape == (1, 256)

											# test num_waveforms_per_prompt=1 (default) for batch of prompts
											_lowerCAmelCase:Dict									=  2
											_lowerCAmelCase:List[str]									=  audioldm_pipe([prompt] * batch_size     ,num_inference_steps=2).audios

											assert audios.shape == (batch_size, 256)

											# test num_waveforms_per_prompt for single prompt
											_lowerCAmelCase:Any									=  2
											_lowerCAmelCase:Tuple									=  audioldm_pipe(a__     ,num_inference_steps=2     ,num_waveforms_per_prompt=a__).audios

											assert audios.shape == (num_waveforms_per_prompt, 256)

											# test num_waveforms_per_prompt for batch of prompts
											_lowerCAmelCase:str									=  2
											_lowerCAmelCase:List[Any]									=  audioldm_pipe(
											    [prompt] * batch_size     ,num_inference_steps=2     ,num_waveforms_per_prompt=a__).audios

											assert audios.shape == (batch_size * num_waveforms_per_prompt, 256)





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




											"""simple docstring"""







											_lowerCAmelCase:Optional[Any]									=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
											_lowerCAmelCase:Dict									=  self.get_dummy_components()
											_lowerCAmelCase:Optional[Any]									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:List[str]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)
											_lowerCAmelCase:Optional[Any]									=  audioldm_pipe.vocoder.config.sampling_rate

											_lowerCAmelCase:Tuple									=  self.get_dummy_inputs(a__)
											_lowerCAmelCase:Optional[Any]									=  audioldm_pipe(audio_length_in_s=0.016     ,**a__)
											_lowerCAmelCase:List[Any]									=  output.audios[0]

											assert audio.ndim == 1
											assert len(a__) / vocoder_sampling_rate == 0.016

											_lowerCAmelCase:List[str]									=  audioldm_pipe(audio_length_in_s=0.032     ,**a__)
											_lowerCAmelCase:Optional[int]									=  output.audios[0]

											assert audio.ndim == 1
											assert len(a__) / vocoder_sampling_rate == 0.032





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




											"""simple docstring"""







											_lowerCAmelCase:Optional[Any]									=  self.get_dummy_components()
											_lowerCAmelCase:Tuple									=  AudioLDMPipeline(**a__)
											_lowerCAmelCase:Dict									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Optional[int]									=  ['''hey''']

											_lowerCAmelCase:List[str]									=  audioldm_pipe(a__     ,num_inference_steps=1)
											_lowerCAmelCase:Tuple									=  output.audios.shape
											assert audio_shape == (1, 256)

											_lowerCAmelCase:Any									=  audioldm_pipe.vocoder.config
											config.model_in_dim *= 2
											_lowerCAmelCase:Optional[Any]									=  SpeechTaHifiGan(a__).to(a__)
											_lowerCAmelCase:int									=  audioldm_pipe(a__     ,num_inference_steps=1)
											_lowerCAmelCase:List[str]									=  output.audios.shape
											# waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram
											assert audio_shape == (1, 256)





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




											"""simple docstring"""







											self._test_attention_slicing_forward_pass(test_mean_pixel_difference=a__)





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




											"""simple docstring"""







											self._test_inference_batch_single_identical(test_mean_pixel_difference=a__)







						@unittest.skipIf(
						    torch_device != '''cuda''' or not is_xformers_available()     ,reason='''XFormers attention is only available with CUDA and `xformers` installed'''     ,)
						def       __UpperCamelCase     (							self      :	Any)						->       Tuple:




											"""simple docstring"""







											self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=a__)




@slow
class   a__			(       unittest.TestCase  ):





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




											"""simple docstring"""







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





						def       __UpperCamelCase     (							self      :	Union[str, Any]     ,a__      :	Optional[Any]     ,a__      :	int="cpu"     ,a__      :	str=torch.floataa     ,a__      :	Union[str, Any]=0)						->       int:




											"""simple docstring"""







											_lowerCAmelCase:Optional[int]									=  torch.Generator(device=a__).manual_seed(a__)
											_lowerCAmelCase:Tuple									=  np.random.RandomState(a__).standard_normal((1, 8, 128, 16))
											_lowerCAmelCase:List[str]									=  torch.from_numpy(a__).to(device=a__     ,dtype=a__)
											_lowerCAmelCase:Dict									=  {
											    '''prompt''': '''A hammer hitting a wooden surface''',
											    '''latents''': latents,
											    '''generator''': generator,
											    '''num_inference_steps''': 3,
											    '''guidance_scale''': 2.5,
											}
											return inputs





						def       __UpperCamelCase     (							self      :	Dict)						->       int:




											"""simple docstring"""







											_lowerCAmelCase:str									=  AudioLDMPipeline.from_pretrained('''cvssp/audioldm''')
											_lowerCAmelCase:Optional[Any]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Optional[int]									=  self.get_inputs(a__)
											_lowerCAmelCase:Optional[Any]									=  25
											_lowerCAmelCase:int									=  audioldm_pipe(**a__).audios[0]

											assert audio.ndim == 1
											assert len(a__) == 8_1920

											_lowerCAmelCase:int									=  audio[7_7230:7_7240]
											_lowerCAmelCase:Optional[Any]									=  np.array(
											    [-0.4884, -0.4607, 0.0023, 0.5007, 0.5896, 0.5151, 0.3813, -0.0208, -0.3687, -0.4315])
											_lowerCAmelCase:Dict									=  np.abs(expected_slice - audio_slice).max()
											assert max_diff < 1E-2







						def       __UpperCamelCase     (							self      :	List[str])						->       str:




											"""simple docstring"""







											_lowerCAmelCase:Union[str, Any]									=  AudioLDMPipeline.from_pretrained('''cvssp/audioldm''')
											_lowerCAmelCase:List[Any]									=  LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config)
											_lowerCAmelCase:Union[str, Any]									=  audioldm_pipe.to(a__)
											audioldm_pipe.set_progress_bar_config(disable=a__)

											_lowerCAmelCase:Optional[Any]									=  self.get_inputs(a__)
											_lowerCAmelCase:Union[str, Any]									=  audioldm_pipe(**a__).audios[0]

											assert audio.ndim == 1
											assert len(a__) == 8_1920

											_lowerCAmelCase:Tuple									=  audio[2_7780:2_7790]
											_lowerCAmelCase:Optional[Any]									=  np.array([-0.2131, -0.0873, -0.0124, -0.0189, 0.0569, 0.1373, 0.1883, 0.2886, 0.3297, 0.2212])
											_lowerCAmelCase:Tuple									=  np.abs(expected_slice - audio_slice).max()
											assert max_diff < 3E-2






