

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  _lowerCAmelCase  (     lowercase					,unittest.TestCase       ):







 """simple docstring"""







 __UpperCAmelCase     : List[str]       		=     AudioLDMPipeline
 __UpperCAmelCase     : Dict       		=     TEXT_TO_AUDIO_PARAMS
 __UpperCAmelCase     : Optional[int]       		=     TEXT_TO_AUDIO_BATCH_PARAMS
 __UpperCAmelCase     : Any       		=     frozenset(
     [
         "num_inference_steps",
         "num_waveforms_per_prompt",
         "generator",
         "latents",
         "output_type",
         "return_dict",
         "callback",
         "callback_steps",
     ]       )


 def  _lowercase			(      self							:      str     ):
    torch.manual_seed(0     )
    __lowercase								=						UNetaDConditionModel(
        block_out_channels=(3_2, 6_4), layers_per_block=2, sample_size=3_2, in_channels=4, out_channels=4, down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"), up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"), cross_attention_dim=(3_2, 6_4), class_embed_type="simple_projection", projection_class_embeddings_input_dim=3_2, class_embeddings_concat=UpperCAmelCase__, )
    __lowercase								=						DDIMScheduler(
        beta_start=0.00_085, beta_end=0.012, beta_schedule="scaled_linear", clip_sample=UpperCAmelCase__, set_alpha_to_one=UpperCAmelCase__, )
    torch.manual_seed(0     )
    __lowercase								=						AutoencoderKL(
        block_out_channels=[3_2, 6_4], in_channels=1, out_channels=1, down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"], up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"], latent_channels=4, )
    torch.manual_seed(0     )
    __lowercase								=						ClapTextConfig(
        bos_token_id=0, eos_token_id=2, hidden_size=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, projection_dim=3_2, )
    __lowercase								=						ClapTextModelWithProjection(UpperCAmelCase__     )
    __lowercase								=						RobertaTokenizer.from_pretrained("hf-internal-testing/tiny-random-roberta", model_max_length=7_7     )

    __lowercase								=						SpeechTaHifiGanConfig(
        model_in_dim=8, sampling_rate=1_6_0_0_0, upsample_initial_channel=1_6, 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=UpperCAmelCase__, )

    __lowercase								=						SpeechTaHifiGan(UpperCAmelCase__     )

    __lowercase								=						{
        "unet": unet,
        "scheduler": scheduler,
        "vae": vae,
        "text_encoder": text_encoder,
        "tokenizer": tokenizer,
        "vocoder": vocoder,
    }
    return components


 def  _lowercase			(      self							:      Union[str, Any], UpperCAmelCase__							:      str, UpperCAmelCase__							:      List[Any]=0     ):
    if str(UpperCAmelCase__     ).startswith("mps"     ):
       __lowercase								=						torch.manual_seed(UpperCAmelCase__     )
    else:
       __lowercase								=						torch.Generator(device=UpperCAmelCase__     ).manual_seed(UpperCAmelCase__     )
    __lowercase								=						{
        "prompt": "A hammer hitting a wooden surface",
        "generator": generator,
        "num_inference_steps": 2,
        "guidance_scale": 6.0,
    }
    return inputs


 def  _lowercase			(      self							:      Tuple     ):
    __lowercase								=						"cpu"  # ensure determinism for the device-dependent torch.Generator

    __lowercase								=						self.get_dummy_components()
    __lowercase								=						AudioLDMPipeline(**UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase__     )

    __lowercase								=						self.get_dummy_inputs(UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe(**UpperCAmelCase__     )
    __lowercase								=						output.audios[0]

    assert audio.ndim == 1
    assert len(UpperCAmelCase__     ) == 2_5_6

    __lowercase								=						audio[:1_0]
    __lowercase								=						np.array(
        [-0.0_050, 0.0_050, -0.0_060, 0.0_033, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_033]     )

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


 def  _lowercase			(      self							:      int     ):
    __lowercase								=						self.get_dummy_components()
    __lowercase								=						AudioLDMPipeline(**UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase__     )

    __lowercase								=						self.get_dummy_inputs(UpperCAmelCase__     )
    __lowercase								=						3 * [inputs["prompt"]]

    # forward
    __lowercase								=						audioldm_pipe(**UpperCAmelCase__     )
    __lowercase								=						output.audios[0]

    __lowercase								=						self.get_dummy_inputs(UpperCAmelCase__     )
    __lowercase								=						3 * [inputs.pop("prompt"     )]

    __lowercase								=						audioldm_pipe.tokenizer(
        UpperCAmelCase__, padding="max_length", max_length=audioldm_pipe.tokenizer.model_max_length, truncation=UpperCAmelCase__, return_tensors="pt", )
    __lowercase								=						text_inputs["input_ids"].to(UpperCAmelCase__     )

    __lowercase								=						audioldm_pipe.text_encoder(
        UpperCAmelCase__, )
    __lowercase								=						prompt_embeds.text_embeds
    # additional L_2 normalization over each hidden-state
    __lowercase								=						F.normalize(UpperCAmelCase__, dim=-1     )

    __lowercase								=						prompt_embeds

    # forward
    __lowercase								=						audioldm_pipe(**UpperCAmelCase__     )
    __lowercase								=						output.audios[0]

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


 def  _lowercase			(      self							:      List[str]     ):
    __lowercase								=						self.get_dummy_components()
    __lowercase								=						AudioLDMPipeline(**UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase__     )

    __lowercase								=						self.get_dummy_inputs(UpperCAmelCase__     )
    __lowercase								=						3 * ["this is a negative prompt"]
    __lowercase								=						negative_prompt
    __lowercase								=						3 * [inputs["prompt"]]

    # forward
    __lowercase								=						audioldm_pipe(**UpperCAmelCase__     )
    __lowercase								=						output.audios[0]

    __lowercase								=						self.get_dummy_inputs(UpperCAmelCase__     )
    __lowercase								=						3 * [inputs.pop("prompt"     )]

    __lowercase								=						[]
    for p in [prompt, negative_prompt]:
       __lowercase								=						audioldm_pipe.tokenizer(
           UpperCAmelCase__, padding="max_length", max_length=audioldm_pipe.tokenizer.model_max_length, truncation=UpperCAmelCase__, return_tensors="pt", )
       __lowercase								=						text_inputs["input_ids"].to(UpperCAmelCase__     )

       __lowercase								=						audioldm_pipe.text_encoder(
           UpperCAmelCase__, )
       __lowercase								=						text_embeds.text_embeds
       # additional L_2 normalization over each hidden-state
       __lowercase								=						F.normalize(UpperCAmelCase__, dim=-1     )

       embeds.append(UpperCAmelCase__     )

    __lowercase		,__lowercase								=						embeds

    # forward
    __lowercase								=						audioldm_pipe(**UpperCAmelCase__     )
    __lowercase								=						output.audios[0]

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


 def  _lowercase			(      self							:      Dict     ):
    __lowercase								=						"cpu"  # ensure determinism for the device-dependent torch.Generator
    __lowercase								=						self.get_dummy_components()
    __lowercase								=						PNDMScheduler(skip_prk_steps=UpperCAmelCase__     )
    __lowercase								=						AudioLDMPipeline(**UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase__     )

    __lowercase								=						self.get_dummy_inputs(UpperCAmelCase__     )
    __lowercase								=						"egg cracking"
    __lowercase								=						audioldm_pipe(**UpperCAmelCase__, negative_prompt=UpperCAmelCase__     )
    __lowercase								=						output.audios[0]

    assert audio.ndim == 1
    assert len(UpperCAmelCase__     ) == 2_5_6

    __lowercase								=						audio[:1_0]
    __lowercase								=						np.array(
        [-0.0_051, 0.0_050, -0.0_060, 0.0_034, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_032]     )

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


 def  _lowercase			(      self							:      int     ):
    __lowercase								=						"cpu"  # ensure determinism for the device-dependent torch.Generator
    __lowercase								=						self.get_dummy_components()
    __lowercase								=						PNDMScheduler(skip_prk_steps=UpperCAmelCase__     )
    __lowercase								=						AudioLDMPipeline(**UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase__     )

    __lowercase								=						"A hammer hitting a wooden surface"

    # test num_waveforms_per_prompt=1 (default)
    __lowercase								=						audioldm_pipe(UpperCAmelCase__, num_inference_steps=2     ).audios

    assert audios.shape == (1, 2_5_6)

    # test num_waveforms_per_prompt=1 (default) for batch of prompts
    __lowercase								=						2
    __lowercase								=						audioldm_pipe([prompt] * batch_size, num_inference_steps=2     ).audios

    assert audios.shape == (batch_size, 2_5_6)

    # test num_waveforms_per_prompt for single prompt
    __lowercase								=						2
    __lowercase								=						audioldm_pipe(UpperCAmelCase__, num_inference_steps=2, num_waveforms_per_prompt=UpperCAmelCase__     ).audios

    assert audios.shape == (num_waveforms_per_prompt, 2_5_6)

    # test num_waveforms_per_prompt for batch of prompts
    __lowercase								=						2
    __lowercase								=						audioldm_pipe(
        [prompt] * batch_size, num_inference_steps=2, num_waveforms_per_prompt=UpperCAmelCase__     ).audios

    assert audios.shape == (batch_size * num_waveforms_per_prompt, 2_5_6)


 def  _lowercase			(      self							:      List[str]     ):
    __lowercase								=						"cpu"  # ensure determinism for the device-dependent torch.Generator
    __lowercase								=						self.get_dummy_components()
    __lowercase								=						AudioLDMPipeline(**UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.vocoder.config.sampling_rate

    __lowercase								=						self.get_dummy_inputs(UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe(audio_length_in_s=0.016, **UpperCAmelCase__     )
    __lowercase								=						output.audios[0]

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

    __lowercase								=						audioldm_pipe(audio_length_in_s=0.032, **UpperCAmelCase__     )
    __lowercase								=						output.audios[0]

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


 def  _lowercase			(      self							:      List[Any]     ):
    __lowercase								=						self.get_dummy_components()
    __lowercase								=						AudioLDMPipeline(**UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase__     )

    __lowercase								=						["hey"]

    __lowercase								=						audioldm_pipe(UpperCAmelCase__, num_inference_steps=1     )
    __lowercase								=						output.audios.shape
    assert audio_shape == (1, 2_5_6)

    __lowercase								=						audioldm_pipe.vocoder.config
    config.model_in_dim *= 2
    __lowercase								=						SpeechTaHifiGan(UpperCAmelCase__     ).to(UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe(UpperCAmelCase__, num_inference_steps=1     )
    __lowercase								=						output.audios.shape
    # waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram
    assert audio_shape == (1, 2_5_6)


 def  _lowercase			(      self							:      Union[str, Any]     ):
    self._test_attention_slicing_forward_pass(test_mean_pixel_difference=UpperCAmelCase__     )


 def  _lowercase			(      self							:      List[Any]     ):
    self._test_inference_batch_single_identical(test_mean_pixel_difference=UpperCAmelCase__     )



 @unittest.skipIf(
     torch_device != "cuda" or not is_xformers_available(), reason="XFormers attention is only available with CUDA and `xformers` installed", )
 def  _lowercase			(      self							:      Optional[Any]     ):
    self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=UpperCAmelCase__     )







@slow
class  _lowerCAmelCase  (     unittest.TestCase       ):







 """simple docstring"""







 def  _lowercase			(      self							:      Dict     ):
    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()


 def  _lowercase			(      self							:      int, UpperCAmelCase__							:      Dict, UpperCAmelCase__							:      str="cpu", UpperCAmelCase__							:      Union[str, Any]=torch.floataa, UpperCAmelCase__							:      Optional[Any]=0     ):
    __lowercase								=						torch.Generator(device=UpperCAmelCase__     ).manual_seed(UpperCAmelCase__     )
    __lowercase								=						np.random.RandomState(UpperCAmelCase__     ).standard_normal((1, 8, 1_2_8, 1_6)     )
    __lowercase								=						torch.from_numpy(UpperCAmelCase__     ).to(device=UpperCAmelCase__, dtype=UpperCAmelCase__     )
    __lowercase								=						{
        "prompt": "A hammer hitting a wooden surface",
        "latents": latents,
        "generator": generator,
        "num_inference_steps": 3,
        "guidance_scale": 2.5,
    }
    return inputs


 def  _lowercase			(      self							:      Dict     ):
    __lowercase								=						AudioLDMPipeline.from_pretrained("cvssp/audioldm"     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase__     )

    __lowercase								=						self.get_inputs(UpperCAmelCase__     )
    __lowercase								=						2_5
    __lowercase								=						audioldm_pipe(**UpperCAmelCase__     ).audios[0]

    assert audio.ndim == 1
    assert len(UpperCAmelCase__     ) == 8_1_9_2_0

    __lowercase								=						audio[7_7_2_3_0:7_7_2_4_0]
    __lowercase								=						np.array(
        [-0.4_884, -0.4_607, 0.0_023, 0.5_007, 0.5_896, 0.5_151, 0.3_813, -0.0_208, -0.3_687, -0.4_315]     )
    __lowercase								=						np.abs(expected_slice - audio_slice     ).max()
    assert max_diff < 1E-2



 def  _lowercase			(      self							:      Optional[int]     ):
    __lowercase								=						AudioLDMPipeline.from_pretrained("cvssp/audioldm"     )
    __lowercase								=						LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config     )
    __lowercase								=						audioldm_pipe.to(UpperCAmelCase__     )
    audioldm_pipe.set_progress_bar_config(disable=UpperCAmelCase__     )

    __lowercase								=						self.get_inputs(UpperCAmelCase__     )
    __lowercase								=						audioldm_pipe(**UpperCAmelCase__     ).audios[0]

    assert audio.ndim == 1
    assert len(UpperCAmelCase__     ) == 8_1_9_2_0

    __lowercase								=						audio[2_7_7_8_0:2_7_7_9_0]
    __lowercase								=						np.array([-0.2_131, -0.0_873, -0.0_124, -0.0_189, 0.0_569, 0.1_373, 0.1_883, 0.2_886, 0.3_297, 0.2_212]     )
    __lowercase								=						np.abs(expected_slice - audio_slice     ).max()
    assert max_diff < 3E-2







"""simple docstring"""





import numpy

# List of input, output pairs
_a							=							(
    ((5, 2, 3), 15),
    ((6, 5, 9), 25),
    ((11, 12, 13), 41),
    ((1, 1, 1), 8),
    ((11, 12, 13), 41),
)
_a							=							(((5_15, 22, 13), 5_55), ((61, 35, 49), 1_50))
_a							=							[2, 4, 1, 5]
_a							=							len(train_data)
_a							=							0.009




def   _A  (  UpperCamelCase_					:	str,      UpperCamelCase_					:	List[Any]="train")     ->						Optional[Any]:
   '''simple docstring'''


   return calculate_hypothesis_value(UpperCamelCase_,      UpperCamelCase_) - output(
       UpperCamelCase_,      UpperCamelCase_)




def   _A  (  UpperCamelCase_					:	List[Any])     ->						Union[str, Any]:
   '''simple docstring'''


   __lowercase								=						0
   for i in range(len(UpperCamelCase_) - 1):
      hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
   hyp_val += parameter_vector[0]
   return hyp_val




def   _A  (  UpperCamelCase_					:	Dict,      UpperCamelCase_					:	Optional[int])     ->						Dict:
   '''simple docstring'''


   if data_set == "train":
      return train_data[example_no][1]
   elif data_set == "test":
      return test_data[example_no][1]
   return None




def   _A  (  UpperCamelCase_					:	Dict,      UpperCamelCase_					:	List[str])     ->						int:
   '''simple docstring'''


   if data_set == "train":
      return _hypothesis_value(train_data[example_no][0])
   elif data_set == "test":
      return _hypothesis_value(test_data[example_no][0])
   return None




def   _A  (  UpperCamelCase_					:	Any,      UpperCamelCase_					:	Tuple=m)     ->						int:
   '''simple docstring'''


   __lowercase								=						0
   for i in range(UpperCamelCase_):
      if index == -1:
         summation_value += _error(UpperCamelCase_)
      else:
         summation_value += _error(UpperCamelCase_) * train_data[i][0][index]
   return summation_value




def   _A  (  UpperCamelCase_					:	str)     ->						str:
   '''simple docstring'''


   __lowercase								=						summation_of_cost_derivative(UpperCamelCase_,      UpperCamelCase_) / m
   return cost_derivative_value




def   _A  (  )     ->						List[str]:
   '''simple docstring'''


   global parameter_vector
   # Tune these values to set a tolerance value for predicted output
   __lowercase								=						0.000_002
   __lowercase								=						0
   __lowercase								=						0
   while True:
      j += 1
      __lowercase								=						[0, 0, 0, 0]
      for i in range(0,      len(UpperCamelCase_)):
         __lowercase								=						get_cost_derivative(i - 1)
         __lowercase								=						(
             parameter_vector[i] - LEARNING_RATE * cost_derivative
         )
      if numpy.allclose(
          UpperCamelCase_,      UpperCamelCase_,      atol=UpperCamelCase_,      rtol=UpperCamelCase_,      ):
         break
      __lowercase								=						temp_parameter_vector
   print(("Number of iterations:", j))




def   _A  (  )     ->						int:
   '''simple docstring'''


   for i in range(len(UpperCamelCase_)):
      print(("Actual output value:", output(UpperCamelCase_,      "test")))
      print(("Hypothesis output:", calculate_hypothesis_value(UpperCamelCase_,      "test")))


if __name__ == "__main__":
   run_gradient_descent()
   print('\nTesting gradient descent for a linear hypothesis function.\n')
   test_gradient_descent()




