






'''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 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase   ,   unittest.TestCase  ):
      __a	       =AudioLDMPipeline
      __a	       =TEXT_TO_AUDIO_PARAMS
      __a	       =TEXT_TO_AUDIO_BATCH_PARAMS
      __a	       =frozenset(
          [
              "num_inference_steps",
              "num_waveforms_per_prompt",
              "generator",
              "latents",
              "output_type",
              "return_dict",
              "callback",
              "callback_steps",
          ]  )




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



         '''simple docstring'''
         torch.manual_seed(0   )
         __a					  =     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=lowerCamelCase			, )
         __a					  =     DDIMScheduler(
             beta_start=0.00085			, beta_end=0.012			, beta_schedule='scaled_linear'			, clip_sample=lowerCamelCase			, set_alpha_to_one=lowerCamelCase			, )
         torch.manual_seed(0   )
         __a					  =     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   )
         __a					  =     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			, )
         __a					  =     ClapTextModelWithProjection(lowerCamelCase   )
         __a					  =     RobertaTokenizer.from_pretrained('hf-internal-testing/tiny-random-roberta'			, model_max_length=77   )

         __a					  =     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=lowerCamelCase			, )

         __a					  =     SpeechTaHifiGan(lowerCamelCase   )

         __a					  =     {
             'unet': unet,
             'scheduler': scheduler,
             'vae': vae,
             'text_encoder': text_encoder,
             'tokenizer': tokenizer,
             'vocoder': vocoder,
         }
         return components




      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase=0   )				->Optional[Any]:



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




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



         '''simple docstring'''
         __a					  =     'cpu'  # ensure determinism for the device-dependent torch.Generator

         __a					  =     self.get_dummy_components()
         __a					  =     AudioLDMPipeline(**lowerCamelCase   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase   )

         __a					  =     self.get_dummy_inputs(lowerCamelCase   )
         __a					  =     audioldm_pipe(**lowerCamelCase   )
         __a					  =     output.audios[0]

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

         __a					  =     audio[:10]
         __a					  =     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   )				->Any:



         '''simple docstring'''
         __a					  =     self.get_dummy_components()
         __a					  =     AudioLDMPipeline(**lowerCamelCase   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase   )

         __a					  =     self.get_dummy_inputs(lowerCamelCase   )
         __a					  =     3 * [inputs['prompt']]

         # forward
         __a					  =     audioldm_pipe(**lowerCamelCase   )
         __a					  =     output.audios[0]

         __a					  =     self.get_dummy_inputs(lowerCamelCase   )
         __a					  =     3 * [inputs.pop('prompt'   )]

         __a					  =     audioldm_pipe.tokenizer(
             lowerCamelCase			, padding='max_length'			, max_length=audioldm_pipe.tokenizer.model_max_length			, truncation=lowerCamelCase			, return_tensors='pt'			, )
         __a					  =     text_inputs['input_ids'].to(lowerCamelCase   )

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

         __a					  =     prompt_embeds

         # forward
         __a					  =     audioldm_pipe(**lowerCamelCase   )
         __a					  =     output.audios[0]

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




      def 			__UpperCamelCase				(	self   )				->Any:



         '''simple docstring'''
         __a					  =     self.get_dummy_components()
         __a					  =     AudioLDMPipeline(**lowerCamelCase   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase   )

         __a					  =     self.get_dummy_inputs(lowerCamelCase   )
         __a					  =     3 * ['this is a negative prompt']
         __a					  =     negative_prompt
         __a					  =     3 * [inputs['prompt']]

         # forward
         __a					  =     audioldm_pipe(**lowerCamelCase   )
         __a					  =     output.audios[0]

         __a					  =     self.get_dummy_inputs(lowerCamelCase   )
         __a					  =     3 * [inputs.pop('prompt'   )]

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

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

            embeds.append(lowerCamelCase   )

         __a  ,      __a					  =     embeds

         # forward
         __a					  =     audioldm_pipe(**lowerCamelCase   )
         __a					  =     output.audios[0]

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




      def 			__UpperCamelCase				(	self   )				->Tuple:



         '''simple docstring'''
         __a					  =     'cpu'  # ensure determinism for the device-dependent torch.Generator
         __a					  =     self.get_dummy_components()
         __a					  =     PNDMScheduler(skip_prk_steps=lowerCamelCase   )
         __a					  =     AudioLDMPipeline(**lowerCamelCase   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase   )

         __a					  =     self.get_dummy_inputs(lowerCamelCase   )
         __a					  =     'egg cracking'
         __a					  =     audioldm_pipe(**lowerCamelCase			, negative_prompt=lowerCamelCase   )
         __a					  =     output.audios[0]

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

         __a					  =     audio[:10]
         __a					  =     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   )				->int:



         '''simple docstring'''
         __a					  =     'cpu'  # ensure determinism for the device-dependent torch.Generator
         __a					  =     self.get_dummy_components()
         __a					  =     PNDMScheduler(skip_prk_steps=lowerCamelCase   )
         __a					  =     AudioLDMPipeline(**lowerCamelCase   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase   )

         __a					  =     'A hammer hitting a wooden surface'

         # test num_waveforms_per_prompt=1 (default)
         __a					  =     audioldm_pipe(lowerCamelCase			, num_inference_steps=2   ).audios

         assert audios.shape == (1, 256)

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

         assert audios.shape == (batch_size, 256)

         # test num_waveforms_per_prompt for single prompt
         __a					  =     2
         __a					  =     audioldm_pipe(lowerCamelCase			, num_inference_steps=2			, num_waveforms_per_prompt=lowerCamelCase   ).audios

         assert audios.shape == (num_waveforms_per_prompt, 256)

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

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




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



         '''simple docstring'''
         __a					  =     'cpu'  # ensure determinism for the device-dependent torch.Generator
         __a					  =     self.get_dummy_components()
         __a					  =     AudioLDMPipeline(**lowerCamelCase   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase   )
         __a					  =     audioldm_pipe.vocoder.config.sampling_rate

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

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

         __a					  =     audioldm_pipe(audio_length_in_s=0.032			, **lowerCamelCase   )
         __a					  =     output.audios[0]

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




      def 			__UpperCamelCase				(	self   )				->Any:



         '''simple docstring'''
         __a					  =     self.get_dummy_components()
         __a					  =     AudioLDMPipeline(**lowerCamelCase   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase   )

         __a					  =     ['hey']

         __a					  =     audioldm_pipe(lowerCamelCase			, num_inference_steps=1   )
         __a					  =     output.audios.shape
         assert audio_shape == (1, 256)

         __a					  =     audioldm_pipe.vocoder.config
         config.model_in_dim *= 2
         __a					  =     SpeechTaHifiGan(lowerCamelCase   ).to(lowerCamelCase   )
         __a					  =     audioldm_pipe(lowerCamelCase			, num_inference_steps=1   )
         __a					  =     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   )				->int:



         '''simple docstring'''
         self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->Any:



         '''simple docstring'''
         self._test_inference_batch_single_identical(test_mean_pixel_difference=lowerCamelCase   )






      @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:



         '''simple docstring'''
         self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCamelCase   )







@slow
class 				__SCREAMING_SNAKE_CASE							(				unittest.TestCase  ):




      def 			__UpperCamelCase				(	self   )				->Tuple:



         '''simple docstring'''
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()




      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase="cpu"			, lowerCamelCase=torch.floataa			, lowerCamelCase=0   )				->int:



         '''simple docstring'''
         __a					  =     torch.Generator(device=lowerCamelCase   ).manual_seed(lowerCamelCase   )
         __a					  =     np.random.RandomState(lowerCamelCase   ).standard_normal((1, 8, 128, 16)   )
         __a					  =     torch.from_numpy(lowerCamelCase   ).to(device=lowerCamelCase			, dtype=lowerCamelCase   )
         __a					  =     {
             'prompt': 'A hammer hitting a wooden surface',
             'latents': latents,
             'generator': generator,
             'num_inference_steps': 3,
             'guidance_scale': 2.5,
         }
         return inputs




      def 			__UpperCamelCase				(	self   )				->int:



         '''simple docstring'''
         __a					  =     AudioLDMPipeline.from_pretrained('cvssp/audioldm'   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase   )

         __a					  =     self.get_inputs(lowerCamelCase   )
         __a					  =     25
         __a					  =     audioldm_pipe(**lowerCamelCase   ).audios[0]

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

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






      def 			__UpperCamelCase				(	self   )				->Any:



         '''simple docstring'''
         __a					  =     AudioLDMPipeline.from_pretrained('cvssp/audioldm'   )
         __a					  =     LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config   )
         __a					  =     audioldm_pipe.to(lowerCamelCase   )
         audioldm_pipe.set_progress_bar_config(disable=lowerCamelCase   )

         __a					  =     self.get_inputs(lowerCamelCase   )
         __a					  =     audioldm_pipe(**lowerCamelCase   ).audios[0]

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

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







'''simple docstring'''



from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


__UpperCamelCase   :							Optional[int]         =   """\
@inproceedings{wang2019glue,
  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
  note={In the Proceedings of ICLR.},
  year={2019}
}
"""

__UpperCamelCase   :							Tuple         =   """\
GLUE, the General Language Understanding Evaluation benchmark
(https://gluebenchmark.com/) is a collection of resources for training,
evaluating, and analyzing natural language understanding systems.
"""

__UpperCamelCase   :							Optional[int]         =   """
Compute GLUE evaluation metric associated to each GLUE dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
Returns: depending on the GLUE subset, one or several of:
    \"accuracy\": Accuracy
    \"f1\": F1 score
    \"pearson\": Pearson Correlation
    \"spearmanr\": Spearman Correlation
    \"matthews_correlation\": Matthew Correlation
Examples:

    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'stsb')
    >>> references = [0., 1., 2., 3., 4., 5.]
    >>> predictions = [0., 1., 2., 3., 4., 5.]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})
    {'pearson': 1.0, 'spearmanr': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'cola')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'matthews_correlation': 1.0}
"""



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						Optional[int],       SCREAMING_SNAKE_CASE__:						str     )	->      List[Any]:

   """simple docstring"""
   return float((preds == labels).mean()     )



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						Optional[Any],       SCREAMING_SNAKE_CASE__:						List[str]     )	->      Optional[Any]:

   """simple docstring"""
   __a					  =     simple_accuracy(SCREAMING_SNAKE_CASE__,       SCREAMING_SNAKE_CASE__     )
   __a					  =     float(fa_score(y_true=SCREAMING_SNAKE_CASE__,       y_pred=SCREAMING_SNAKE_CASE__     )     )
   return {
       "accuracy": acc,
       "f1": fa,
   }



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						int,       SCREAMING_SNAKE_CASE__:						Optional[Any]     )	->      int:

   """simple docstring"""
   __a					  =     float(pearsonr(SCREAMING_SNAKE_CASE__,       SCREAMING_SNAKE_CASE__     )[0]     )
   __a					  =     float(spearmanr(SCREAMING_SNAKE_CASE__,       SCREAMING_SNAKE_CASE__     )[0]     )
   return {
       "pearson": pearson_corr,
       "spearmanr": spearman_corr,
   }



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,   _KWARGS_DESCRIPTION  )
class 				__SCREAMING_SNAKE_CASE							(				datasets.Metric  ):




      def 			__UpperCamelCase				(	self   )				->int:



         '''simple docstring'''
         if self.config_name not in [
             "sst2",
             "mnli",
             "mnli_mismatched",
             "mnli_matched",
             "cola",
             "stsb",
             "mrpc",
             "qqp",
             "qnli",
             "rte",
             "wnli",
             "hans",
         ]:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'   )
         return datasets.MetricInfo(
             description=_DESCRIPTION			, citation=_CITATION			, inputs_description=_KWARGS_DESCRIPTION			, features=datasets.Features(
                 {
                     'predictions': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'   ),
                     'references': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'   ),
                 }   )			, codebase_urls=[]			, reference_urls=[]			, format='numpy'			, )






      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase   )				->Tuple:



         '''simple docstring'''
         if self.config_name == "cola":
            return {"matthews_correlation": matthews_corrcoef(lowerCamelCase			, lowerCamelCase   )}
         elif self.config_name == "stsb":
            return pearson_and_spearman(lowerCamelCase			, lowerCamelCase   )
         elif self.config_name in ["mrpc", "qqp"]:
            return acc_and_fa(lowerCamelCase			, lowerCamelCase   )
         elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
            return {"accuracy": simple_accuracy(lowerCamelCase			, lowerCamelCase   )}
         else:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'   )