





"""simple docstring"""






import gc
import unittest

import numpy as np
import torch

from diffusers import DDPMScheduler, MidiProcessor, SpectrogramDiffusionPipeline
from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder
from diffusers.utils import require_torch_gpu, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_note_seq, require_onnxruntime

from ..pipeline_params import TOKENS_TO_AUDIO_GENERATION_BATCH_PARAMS, TOKENS_TO_AUDIO_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


lowerCAmelCase_      =				'''./tests/fixtures/elise_format0.mid'''



@unittest.skip("""The note-seq package currently throws an error on import"""				)
class 						lowerCAmelCase       (   snake_case      ,						unittest.TestCase				):
       lowerCAmelCase__    			=	SpectrogramDiffusionPipeline
       lowerCAmelCase__    			=	PipelineTesterMixin.required_optional_params - {
           """callback""",
           """latents""",
           """callback_steps""",
           """output_type""",
           """num_images_per_prompt""",
       }
       lowerCAmelCase__    			=	False
       lowerCAmelCase__    			=	False
       lowerCAmelCase__    			=	TOKENS_TO_AUDIO_GENERATION_PARAMS
       lowerCAmelCase__    			=	TOKENS_TO_AUDIO_GENERATION_BATCH_PARAMS






       def 				__A			( self  ):
              torch.manual_seed(0  )
              _UpperCAmelCase			     =  SpectrogramNotesEncoder(
                  max_length=20_48     ,	vocab_size=15_36     ,	d_model=7_68     ,	dropout_rate=0.1     ,	num_layers=1     ,	num_heads=1     ,	d_kv=4     ,	d_ff=20_48     ,	feed_forward_proj='gated-gelu'     ,	)

              _UpperCAmelCase			     =  SpectrogramContEncoder(
                  input_dims=1_28     ,	targets_context_length=2_56     ,	d_model=7_68     ,	dropout_rate=0.1     ,	num_layers=1     ,	num_heads=1     ,	d_kv=4     ,	d_ff=20_48     ,	feed_forward_proj='gated-gelu'     ,	)

              _UpperCAmelCase			     =  TaFilmDecoder(
                  input_dims=1_28     ,	targets_length=2_56     ,	max_decoder_noise_time=20_000.0     ,	d_model=7_68     ,	num_layers=1     ,	num_heads=1     ,	d_kv=4     ,	d_ff=20_48     ,	dropout_rate=0.1     ,	)

              _UpperCAmelCase			     =  DDPMScheduler()

              _UpperCAmelCase			     =  {
                  'notes_encoder': notes_encoder.eval(),
                  'continuous_encoder': continuous_encoder.eval(),
                  'decoder': decoder.eval(),
                  'scheduler': scheduler,
                  'melgan': None,
              }
              return components






       def 				__A			( self     ,	a__     ,	a__=0  ):
              if str(a__  ).startswith('mps'  ):
                     _UpperCAmelCase			     =  torch.manual_seed(a__  )
              else:
                     _UpperCAmelCase			     =  torch.Generator(device=a__  ).manual_seed(a__  )
              _UpperCAmelCase			     =  {
                  'input_tokens': [
                      [11_34, 90, 11_35, 11_33, 10_80, 1_12, 11_32, 10_80, 11_33, 10_79, 1_33, 11_32, 10_79, 11_33, 1] + [0] * 20_33
                  ],
                  'generator': generator,
                  'num_inference_steps': 4,
                  'output_type': 'mel',
              }
              return inputs






       def 				__A			( self  ):
              _UpperCAmelCase			     =  'cpu'  # ensure determinism for the device-dependent torch.Generator
              _UpperCAmelCase			     =  self.get_dummy_components()
              _UpperCAmelCase			     =  SpectrogramDiffusionPipeline(**a__  )
              _UpperCAmelCase			     =  pipe.to(a__  )
              pipe.set_progress_bar_config(disable=a__  )

              _UpperCAmelCase			     =  self.get_dummy_inputs(a__  )
              _UpperCAmelCase			     =  pipe(**a__  )
              _UpperCAmelCase			     =  output.audios

              _UpperCAmelCase			     =  mel[0, -3:, -3:]

              assert mel_slice.shape == (3, 3)
              _UpperCAmelCase			     =  np.array(
                  [-11.512_925, -4.788_215, -0.46_172_905, -2.051_715, -10.539_147, -10.970_963, -9.091_634, 4.0, 4.0]  )
              assert np.abs(mel_slice.flatten() - expected_slice  ).max() < 1E-2






       @skip_mps
       def 				__A			( self  ):
              return super().test_save_load_local()






       @skip_mps
       def 				__A			( self  ):
              return super().test_dict_tuple_outputs_equivalent()






       @skip_mps
       def 				__A			( self  ):
              return super().test_save_load_optional_components()






       @skip_mps
       def 				__A			( self  ):
              return super().test_attention_slicing_forward_pass()






       def 				__A			( self  ):
              pass






       def 				__A			( self  ):
              pass






       @skip_mps
       def 				__A			( self  ):
              return super().test_progress_bar()



@slow
@require_torch_gpu
@require_onnxruntime
@require_note_seq
class 						lowerCAmelCase       (   unittest.TestCase				):






       def 				__A			( self  ):
              # clean up the VRAM after each test
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()






       def 				__A			( self  ):
              # TODO - test that pipeline can decode tokens in a callback
              # so that music can be played live
              _UpperCAmelCase			     =  torch_device

              _UpperCAmelCase			     =  SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion'  )
              _UpperCAmelCase			     =  pipe.melgan
              _UpperCAmelCase			     =  None

              _UpperCAmelCase			     =  pipe.to(a__  )
              pipe.set_progress_bar_config(disable=a__  )

              def callback(a__     ,	a__  ):
                     # decode mel to audio
                     _UpperCAmelCase			     =  melgan(input_features=mel_output.astype(np.floataa  )  )[0]
                     assert len(audio[0]  ) == 8_19_20 * (step + 1)
                     # simulate that audio is played
                     return audio

              _UpperCAmelCase			     =  MidiProcessor()
              _UpperCAmelCase			     =  processor(a__  )

              _UpperCAmelCase			     =  input_tokens[:3]
              _UpperCAmelCase			     =  torch.manual_seed(0  )
              pipe(a__     ,	num_inference_steps=5     ,	generator=a__     ,	callback=a__     ,	output_type='mel'  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  torch_device

              _UpperCAmelCase			     =  SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion'  )
              _UpperCAmelCase			     =  pipe.to(a__  )
              pipe.set_progress_bar_config(disable=a__  )
              _UpperCAmelCase			     =  MidiProcessor()

              _UpperCAmelCase			     =  processor(a__  )
              # just run two denoising loops
              _UpperCAmelCase			     =  input_tokens[:2]

              _UpperCAmelCase			     =  torch.manual_seed(0  )
              _UpperCAmelCase			     =  pipe(a__     ,	num_inference_steps=2     ,	generator=a__  )

              _UpperCAmelCase			     =  output.audios[0]

              assert abs(np.abs(a__  ).sum() - 3_612.841  ) < 1E-1






       def 				__A			( self  ):
              _UpperCAmelCase			     =  torch_device

              _UpperCAmelCase			     =  SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion'  )
              _UpperCAmelCase			     =  pipe.to(a__  )
              pipe.set_progress_bar_config(disable=a__  )

              _UpperCAmelCase			     =  MidiProcessor()

              _UpperCAmelCase			     =  processor(a__  )

              # just run 4 denoising loops
              _UpperCAmelCase			     =  input_tokens[:4]

              _UpperCAmelCase			     =  torch.manual_seed(0  )
              _UpperCAmelCase			     =  pipe(a__     ,	num_inference_steps=1_00     ,	generator=a__  )

              _UpperCAmelCase			     =  output.audios[0]
              assert abs(np.abs(a__  ).sum() - 9_389.1_111  ) < 5E-2













"""simple docstring"""






from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import (
        TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFXLMForMultipleChoice,
        TFXLMForQuestionAnsweringSimple,
        TFXLMForSequenceClassification,
        TFXLMForTokenClassification,
        TFXLMModel,
        TFXLMWithLMHeadModel,
        XLMConfig,
    )



class 						lowerCAmelCase       :






       def __init__( self     ,	a__     ,	):
              _UpperCAmelCase			     =  parent
              _UpperCAmelCase			     =  13
              _UpperCAmelCase			     =  7
              _UpperCAmelCase			     =  True
              _UpperCAmelCase			     =  True
              _UpperCAmelCase			     =  True
              _UpperCAmelCase			     =  True
              _UpperCAmelCase			     =  True
              _UpperCAmelCase			     =  False
              _UpperCAmelCase			     =  False
              _UpperCAmelCase			     =  False
              _UpperCAmelCase			     =  2
              _UpperCAmelCase			     =  99
              _UpperCAmelCase			     =  0
              _UpperCAmelCase			     =  32
              _UpperCAmelCase			     =  2
              _UpperCAmelCase			     =  4
              _UpperCAmelCase			     =  0.1
              _UpperCAmelCase			     =  0.1
              _UpperCAmelCase			     =  5_12
              _UpperCAmelCase			     =  16
              _UpperCAmelCase			     =  2
              _UpperCAmelCase			     =  0.02
              _UpperCAmelCase			     =  3
              _UpperCAmelCase			     =  4
              _UpperCAmelCase			     =  'last'
              _UpperCAmelCase			     =  True
              _UpperCAmelCase			     =  None
              _UpperCAmelCase			     =  0






       def 				__A			( self  ):
              _UpperCAmelCase			     =  ids_tensor([self.batch_size, self.seq_length]     ,	self.vocab_size  )
              _UpperCAmelCase			     =  random_attention_mask([self.batch_size, self.seq_length]     ,	dtype=tf.floataa  )

              _UpperCAmelCase			     =  None
              if self.use_input_lengths:
                     _UpperCAmelCase			     =  (
                         ids_tensor([self.batch_size]     ,	vocab_size=2  ) + self.seq_length - 2
                     )  # small variation of seq_length

              _UpperCAmelCase			     =  None
              if self.use_token_type_ids:
                     _UpperCAmelCase			     =  ids_tensor([self.batch_size, self.seq_length]     ,	self.n_langs  )

              _UpperCAmelCase			     =  None
              _UpperCAmelCase			     =  None
              _UpperCAmelCase			     =  None
              if self.use_labels:
                     _UpperCAmelCase			     =  ids_tensor([self.batch_size]     ,	self.type_sequence_label_size  )
                     _UpperCAmelCase			     =  ids_tensor([self.batch_size, self.seq_length]     ,	self.num_labels  )
                     _UpperCAmelCase			     =  ids_tensor([self.batch_size]     ,	2     ,	dtype=tf.floataa  )
                     _UpperCAmelCase			     =  ids_tensor([self.batch_size]     ,	self.num_choices  )

              _UpperCAmelCase			     =  XLMConfig(
                  vocab_size=self.vocab_size     ,	n_special=self.n_special     ,	emb_dim=self.hidden_size     ,	n_layers=self.num_hidden_layers     ,	n_heads=self.num_attention_heads     ,	dropout=self.hidden_dropout_prob     ,	attention_dropout=self.attention_probs_dropout_prob     ,	gelu_activation=self.gelu_activation     ,	sinusoidal_embeddings=self.sinusoidal_embeddings     ,	asm=self.asm     ,	causal=self.causal     ,	n_langs=self.n_langs     ,	max_position_embeddings=self.max_position_embeddings     ,	initializer_range=self.initializer_range     ,	summary_type=self.summary_type     ,	use_proj=self.use_proj     ,	bos_token_id=self.bos_token_id     ,	)

              return (
                  config,
                  input_ids,
                  token_type_ids,
                  input_lengths,
                  sequence_labels,
                  token_labels,
                  is_impossible_labels,
                  choice_labels,
                  input_mask,
              )






       def 				__A			( self     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	):
              _UpperCAmelCase			     =  TFXLMModel(config=a__  )
              _UpperCAmelCase			     =  {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
              _UpperCAmelCase			     =  model(a__  )

              _UpperCAmelCase			     =  [input_ids, input_mask]
              _UpperCAmelCase			     =  model(a__  )
              self.parent.assertEqual(result.last_hidden_state.shape     ,	(self.batch_size, self.seq_length, self.hidden_size)  )






       def 				__A			( self     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	):
              _UpperCAmelCase			     =  TFXLMWithLMHeadModel(a__  )

              _UpperCAmelCase			     =  {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
              _UpperCAmelCase			     =  model(a__  )

              _UpperCAmelCase			     =  outputs

              self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.vocab_size)  )






       def 				__A			( self     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	):
              _UpperCAmelCase			     =  TFXLMForQuestionAnsweringSimple(a__  )

              _UpperCAmelCase			     =  {'input_ids': input_ids, 'lengths': input_lengths}

              _UpperCAmelCase			     =  model(a__  )

              self.parent.assertEqual(result.start_logits.shape     ,	(self.batch_size, self.seq_length)  )
              self.parent.assertEqual(result.end_logits.shape     ,	(self.batch_size, self.seq_length)  )






       def 				__A			( self     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	):
              _UpperCAmelCase			     =  TFXLMForSequenceClassification(a__  )

              _UpperCAmelCase			     =  {'input_ids': input_ids, 'lengths': input_lengths}

              _UpperCAmelCase			     =  model(a__  )

              self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.type_sequence_label_size)  )






       def 				__A			( self     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	):
              _UpperCAmelCase			     =  self.num_labels
              _UpperCAmelCase			     =  TFXLMForTokenClassification(config=a__  )
              _UpperCAmelCase			     =  {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
              _UpperCAmelCase			     =  model(a__  )
              self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.num_labels)  )






       def 				__A			( self     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__     ,	):
              _UpperCAmelCase			     =  self.num_choices
              _UpperCAmelCase			     =  TFXLMForMultipleChoice(config=a__  )
              _UpperCAmelCase			     =  tf.tile(tf.expand_dims(a__     ,	1  )     ,	(1, self.num_choices, 1)  )
              _UpperCAmelCase			     =  tf.tile(tf.expand_dims(a__     ,	1  )     ,	(1, self.num_choices, 1)  )
              _UpperCAmelCase			     =  tf.tile(tf.expand_dims(a__     ,	1  )     ,	(1, self.num_choices, 1)  )
              _UpperCAmelCase			     =  {
                  'input_ids': multiple_choice_inputs_ids,
                  'attention_mask': multiple_choice_input_mask,
                  'token_type_ids': multiple_choice_token_type_ids,
              }
              _UpperCAmelCase			     =  model(a__  )
              self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.num_choices)  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.prepare_config_and_inputs()
              (
                  (
                  _UpperCAmelCase
              )     ,				(
                  _UpperCAmelCase
              )     ,				(
                  _UpperCAmelCase
              )     ,				(
                  _UpperCAmelCase
              )     ,				(
                  _UpperCAmelCase
              )     ,				(
                  _UpperCAmelCase
              )     ,				(
                  _UpperCAmelCase
              )     ,				(
                  _UpperCAmelCase
              )     ,				(
                  _UpperCAmelCase
              )     ,				
              )			     =  config_and_inputs
              _UpperCAmelCase			     =  {
                  'input_ids': input_ids,
                  'token_type_ids': token_type_ids,
                  'langs': token_type_ids,
                  'lengths': input_lengths,
              }
              return config, inputs_dict



@require_tf
class 						lowerCAmelCase       (   snake_case      ,						snake_case      ,						unittest.TestCase				):
       lowerCAmelCase__    			=	(
           (
               TFXLMModel,
               TFXLMWithLMHeadModel,
               TFXLMForSequenceClassification,
               TFXLMForQuestionAnsweringSimple,
               TFXLMForTokenClassification,
               TFXLMForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       lowerCAmelCase__    			=	(
           (TFXLMWithLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       lowerCAmelCase__    			=	(
           {
               """feature-extraction""": TFXLMModel,
               """fill-mask""": TFXLMWithLMHeadModel,
               """question-answering""": TFXLMForQuestionAnsweringSimple,
               """text-classification""": TFXLMForSequenceClassification,
               """text-generation""": TFXLMWithLMHeadModel,
               """token-classification""": TFXLMForTokenClassification,
               """zero-shot""": TFXLMForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       lowerCAmelCase__    			=	False
       lowerCAmelCase__    			=	False






       def 				__A			( self     ,	a__     ,	a__     ,	a__     ,	a__     ,	a__  ):
              if (
                  pipeline_test_casse_name == "QAPipelineTests"
                  and tokenizer_name is not None
                  and not tokenizer_name.endswith('Fast'  )
              ):
                     # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
                     # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
                     # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
                     return True

              return False






       def 				__A			( self  ):
              _UpperCAmelCase			     =  TFXLMModelTester(self  )
              _UpperCAmelCase			     =  ConfigTester(self     ,	config_class=a__     ,	emb_dim=37  )






       def 				__A			( self  ):
              self.config_tester.run_common_tests()






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_model(*a__  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_lm_head(*a__  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_qa(*a__  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_sequence_classif(*a__  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_for_token_classification(*a__  )






       def 				__A			( self  ):
              _UpperCAmelCase			     =  self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_xlm_for_multiple_choice(*a__  )






       @slow
       def 				__A			( self  ):
              for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                     _UpperCAmelCase			     =  TFXLMModel.from_pretrained(a__  )
                     self.assertIsNotNone(a__  )



@require_tf
class 						lowerCAmelCase       (   unittest.TestCase				):






       @slow
       def 				__A			( self  ):
              _UpperCAmelCase			     =  TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'  )
              _UpperCAmelCase			     =  tf.convert_to_tensor([[14, 4_47]]     ,	dtype=tf.intaa  )  # the president
              _UpperCAmelCase			     =  [
                  14,
                  4_47,
                  14,
                  4_47,
                  14,
                  4_47,
                  14,
                  4_47,
                  14,
                  4_47,
                  14,
                  4_47,
                  14,
                  4_47,
                  14,
                  4_47,
                  14,
                  4_47,
                  14,
                  4_47,
              ]  # the president the president the president the president the president the president the president the president the president the president
              # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
              _UpperCAmelCase			     =  model.generate(a__     ,	do_sample=a__  )
              self.assertListEqual(output_ids[0].numpy().tolist()     ,	a__  )






