






from sklearn.metrics import fa_score, matthews_corrcoef

import datasets

from .record_evaluation import evaluate as evaluate_record


snake_case__   :						int													=   """\
@article{wang2019superglue,
  title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},
  author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R},
  journal={arXiv preprint arXiv:1905.00537},
  year={2019}
}
"""

snake_case__   :						Dict													=   """\
SuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after
GLUE with a new set of more difficult language understanding tasks, improved
resources, and a new public leaderboard.
"""

snake_case__   :						Dict													=   """
Compute SuperGLUE evaluation metric associated to each SuperGLUE dataset.
Args:
    predictions: list of predictions to score. Depending on the SuperGlUE subset:
        - for 'record': list of question-answer dictionaries with the following keys:
            - 'idx': index of the question as specified by the dataset
            - 'prediction_text': the predicted answer text
        - for 'multirc': list of question-answer dictionaries with the following keys:
            - 'idx': index of the question-answer pair as specified by the dataset
            - 'prediction': the predicted answer label
        - otherwise: list of predicted labels
    references: list of reference labels. Depending on the SuperGLUE subset:
        - for 'record': list of question-answers dictionaries with the following keys:
            - 'idx': index of the question as specified by the dataset
            - 'answers': list of possible answers
        - otherwise: list of reference labels
Returns: depending on the SuperGLUE subset:
    - for 'record':
        - 'exact_match': Exact match between answer and gold answer
        - 'f1': F1 score
    - for 'multirc':
        - 'exact_match': Exact match between answer and gold answer
        - 'f1_m': Per-question macro-F1 score
        - 'f1_a': Average F1 score over all answers
    - for 'axb':
        'matthews_correlation': Matthew Correlation
    - for 'cb':
        - 'accuracy': Accuracy
        - 'f1': F1 score
    - for all others:
        - 'accuracy': Accuracy
Examples:

    >>> super_glue_metric = datasets.load_metric('super_glue', 'copa')  # any of [\"copa\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"boolq\", \"axg\"]
    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> super_glue_metric = datasets.load_metric('super_glue', 'cb')
    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> super_glue_metric = datasets.load_metric('super_glue', 'record')
    >>> predictions = [{'idx': {'passage': 0, 'query': 0}, 'prediction_text': 'answer'}]
    >>> references = [{'idx': {'passage': 0, 'query': 0}, 'answers': ['answer', 'another_answer']}]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'exact_match': 1.0, 'f1': 1.0}

    >>> super_glue_metric = datasets.load_metric('super_glue', 'multirc')
    >>> predictions = [{'idx': {'answer': 0, 'paragraph': 0, 'question': 0}, 'prediction': 0}, {'idx': {'answer': 1, 'paragraph': 2, 'question': 3}, 'prediction': 1}]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'exact_match': 1.0, 'f1_m': 1.0, 'f1_a': 1.0}

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






def      _snake_case     (__lowercase     ,   __lowercase):
   return float((preds == labels).mean())






def      _snake_case     (__lowercase     ,   __lowercase     ,   __lowercase="binary"):
   UpperCamelCase_						=  simple_accuracy(__lowercase     ,   __lowercase)
   UpperCamelCase_						=  float(fa_score(y_true=__lowercase     ,   y_pred=__lowercase     ,   average=__lowercase))
   return {
       "accuracy": acc,
       "f1": fa,
   }






def      _snake_case     (__lowercase     ,   __lowercase):
   UpperCamelCase_						=  {}
   for id_pred, label in zip(__lowercase     ,   __lowercase):
      UpperCamelCase_						=  f"""{id_pred["idx"]["paragraph"]}-{id_pred["idx"]["question"]}"""
      UpperCamelCase_						=  id_pred['prediction']
      if question_id in question_map:
         question_map[question_id].append((pred, label))
      else:
         UpperCamelCase_						=  [(pred, label)]
   UpperCamelCase_		,   UpperCamelCase_						=  [], []
   for question, preds_labels in question_map.items():
      UpperCamelCase_		,   UpperCamelCase_						=  zip(*__lowercase)
      UpperCamelCase_						=  fa_score(y_true=__lowercase     ,   y_pred=__lowercase     ,   average='macro')
      fas.append(__lowercase)
      UpperCamelCase_						=  int(sum(pred == label for pred, label in preds_labels) == len(__lowercase))
      ems.append(__lowercase)
   UpperCamelCase_						=  float(sum(__lowercase) / len(__lowercase))
   UpperCamelCase_						=  sum(__lowercase) / len(__lowercase)
   UpperCamelCase_						=  float(fa_score(y_true=__lowercase     ,   y_pred=[id_pred['prediction'] for id_pred in ids_preds]))
   return {"exact_match": em, "f1_m": fa_m, "f1_a": fa_a}


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






  """simple docstring"""





  def  _UpperCAmelCase  (  self			)      ->			Optional[Any]:
     if self.config_name not in [
         "boolq",
         "cb",
         "copa",
         "multirc",
         "record",
         "rte",
         "wic",
         "wsc",
         "wsc.fixed",
         "axb",
         "axg",
     ]:
        raise KeyError(
            'You should supply a configuration name selected in '
            '["boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg",]'			)
     return datasets.MetricInfo(
         description=_DESCRIPTION		,		citation=_CITATION		,		inputs_description=_KWARGS_DESCRIPTION		,		features=datasets.Features(self._get_feature_types()			)		,		codebase_urls=[]		,		reference_urls=[]		,		format='numpy' if not self.config_name == 'record' and not self.config_name == 'multirc' else None		,		)




  def  _UpperCAmelCase  (  self			)      ->			str:
     if self.config_name == "record":
        return {
            "predictions": {
                "idx": {
                    "passage": datasets.Value('int64'			),
                    "query": datasets.Value('int64'			),
                },
                "prediction_text": datasets.Value('string'			),
            },
            "references": {
                "idx": {
                    "passage": datasets.Value('int64'			),
                    "query": datasets.Value('int64'			),
                },
                "answers": datasets.Sequence(datasets.Value('string'			)			),
            },
        }
     elif self.config_name == "multirc":
        return {
            "predictions": {
                "idx": {
                    "answer": datasets.Value('int64'			),
                    "paragraph": datasets.Value('int64'			),
                    "question": datasets.Value('int64'			),
                },
                "prediction": datasets.Value('int64'			),
            },
            "references": datasets.Value('int64'			),
        }
     else:
        return {
            "predictions": datasets.Value('int64'			),
            "references": datasets.Value('int64'			),
        }




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Tuple:
     if self.config_name == "axb":
        return {"matthews_correlation": matthews_corrcoef(_UpperCAmelCase		,		_UpperCAmelCase			)}
     elif self.config_name == "cb":
        return acc_and_fa(_UpperCAmelCase		,		_UpperCAmelCase		,		fa_avg='macro'			)
     elif self.config_name == "record":
        UpperCamelCase_						=  [
            {
                'qas': [
                    {'id': ref['idx']['query'], 'answers': [{'text': ans} for ans in ref['answers']]}
                    for ref in references
                ]
            }
        ]
        UpperCamelCase_						=  {pred['idx']['query']: pred['prediction_text'] for pred in predictions}
        return evaluate_record(_UpperCAmelCase		,		_UpperCAmelCase			)[0]
     elif self.config_name == "multirc":
        return evaluate_multirc(_UpperCAmelCase		,		_UpperCAmelCase			)
     elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]:
        return {"accuracy": simple_accuracy(_UpperCAmelCase		,		_UpperCAmelCase			)}
     else:
        raise KeyError(
            'You should supply a configuration name selected in '
            '["boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg",]'			)










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__	(    UpperCAmelCase_							,     unittest.TestCase):
     """simple docstring"""



     _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     _a   (self     ):






           '''simple docstring'''



           torch.manual_seed(0     )
           lowerCamelCase             =		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             =		DDIMScheduler(
               beta_start=0.0_0085					,      beta_end=0.012					,      beta_schedule="scaled_linear"					,      clip_sample=__a					,      set_alpha_to_one=__a					,      )
           torch.manual_seed(0     )
           lowerCamelCase             =		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             =		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=10_00					,      projection_dim=32					,      )
           lowerCamelCase             =		ClapTextModelWithProjection(__a     )
           lowerCamelCase             =		RobertaTokenizer.from_pretrained("hf-internal-testing/tiny-random-roberta"					,      model_max_length=77     )

           lowerCamelCase             =		SpeechTaHifiGanConfig(
               model_in_dim=8					,      sampling_rate=1_60_00					,      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             =		SpeechTaHifiGan(__a     )

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







     def     _a   (self					,      __a					,      __a=0     ):






           '''simple docstring'''



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







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		"cpu"  # ensure determinism for the device-dependent torch.Generator

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

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

           assert audio.ndim == 1
           assert len(__a     ) == 2_56

           lowerCamelCase             =		audio[:10]
           lowerCamelCase             =		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     _a   (self     ):






           '''simple docstring'''



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

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

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

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

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

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

           lowerCamelCase             =		prompt_embeds

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

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







     def     _a   (self     ):






           '''simple docstring'''



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

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

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

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

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

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

                 embeds.append(__a     )

           lowerCamelCase      ,				lowerCamelCase             =		embeds

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

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







     def     _a   (self     ):






           '''simple docstring'''



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

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

           assert audio.ndim == 1
           assert len(__a     ) == 2_56

           lowerCamelCase             =		audio[:10]
           lowerCamelCase             =		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     _a   (self     ):






           '''simple docstring'''



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

           lowerCamelCase             =		"A hammer hitting a wooden surface"

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

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

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

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

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

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

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

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







     def     _a   (self     ):






           '''simple docstring'''



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

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

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

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

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







     def     _a   (self     ):






           '''simple docstring'''



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

           lowerCamelCase             =		["hey"]

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

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







     def     _a   (self     ):






           '''simple docstring'''



           self._test_attention_slicing_forward_pass(test_mean_pixel_difference=__a     )







     def     _a   (self     ):






           '''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     _a   (self     ):






           '''simple docstring'''



           self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=__a     )





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



     def     _a   (self     ):






           '''simple docstring'''



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







     def     _a   (self					,      __a					,      __a="cpu"					,      __a=torch.floataa					,      __a=0     ):






           '''simple docstring'''



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







     def     _a   (self     ):






           '''simple docstring'''



           lowerCamelCase             =		AudioLDMPipeline.from_pretrained("cvssp/audioldm"     )
           lowerCamelCase             =		audioldm_pipe.to(__a     )
           audioldm_pipe.set_progress_bar_config(disable=__a     )

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

           assert audio.ndim == 1
           assert len(__a     ) == 8_19_20

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







     def     _a   (self     ):






           '''simple docstring'''



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

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

           assert audio.ndim == 1
           assert len(__a     ) == 8_19_20

           lowerCamelCase             =		audio[2_77_80:2_77_90]
           lowerCamelCase             =		np.array([-0.2131, -0.0873, -0.0124, -0.0189, 0.0569, 0.1373, 0.1883, 0.2886, 0.3297, 0.2212]     )
           lowerCamelCase             =		np.abs(expected_slice - audio_slice     ).max()
           assert max_diff < 3E-2