code: 
  
  
  
  
  
  import argparse
  import os
  from functools import reduce
  
  import fairseq
  import torch
  from datasets import load_dataset
  
  from transformers import WavaVecaProcessor, logging
  from transformers.models.dataavec.configuration_dataavec_audio import DataaVecAudioConfig
  
  # Copied from https://github.com/pytorch/fairseq/blob/main/examples/data2vec/models/data2vec_audio.py
  from transformers.models.dataavec.dataavec_audio import DataaVecAudioModel as Dummy  # noqa: F401
  from transformers.models.dataavec.modeling_dataavec_audio import DataaVecAudioForCTC, DataaVecAudioModel
  
  
  logging.set_verbosity_info()
  _lowercase		:     List[Any] 					=logging.get_logger(__name__)
  
  _lowercase		:     Dict 					={
      """post_extract_proj""": """feature_projection.projection""",
      """models.0.layer_norm""": """feature_projection.layer_norm""",
      """self_attn.k_proj""": """encoder.layers.*.attention.k_proj""",
      """self_attn.v_proj""": """encoder.layers.*.attention.v_proj""",
      """self_attn.q_proj""": """encoder.layers.*.attention.q_proj""",
      """self_attn.out_proj""": """encoder.layers.*.attention.out_proj""",
      """self_attn_layer_norm""": """encoder.layers.*.layer_norm""",
      """fc1""": """encoder.layers.*.feed_forward.intermediate_dense""",
      """fc2""": """encoder.layers.*.feed_forward.output_dense""",
      """final_layer_norm""": """encoder.layers.*.final_layer_norm""",
      """encoder.layer_norm""": """encoder.layer_norm""",
      """w2v_model.layer_norm""": """feature_projection.layer_norm""",
      """w2v_encoder.proj""": """lm_head""",
      """mask_emb""": """masked_spec_embed""",
  }
  _lowercase		:     Optional[int] 					=[
      """lm_head""",
  ]
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	):
  		for attribute in key.split('.'	):
  				lowerCamelCase_  :    Tuple   	=			getattr(lowerCAmelCase__       ,lowerCAmelCase__	)
  
  		if weight_type is not None:
  				lowerCamelCase_  :    Optional[Any]   	=			getattr(lowerCAmelCase__       ,lowerCAmelCase__	).shape
  		else:
  				lowerCamelCase_  :    int   	=			hf_pointer.shape
  
  		if hf_shape != value.shape:
  				raise ValueError(
  				    F"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
  				    F" {value.shape} for {full_name}"	)
  
  		if weight_type == "weight":
  				lowerCamelCase_  :    Optional[int]   	=			value
  		elif weight_type == "weight_g":
  				lowerCamelCase_  :    Any   	=			value
  		elif weight_type == "weight_v":
  				lowerCamelCase_  :    Optional[int]   	=			value
  		elif weight_type == "bias":
  				lowerCamelCase_  :    str   	=			value
  		else:
  				lowerCamelCase_  :    List[Any]   	=			value
  
  		logger.info(F"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	):
  		lowerCamelCase_  :    Dict   	=			[]
  		lowerCamelCase_  :    List[Any]   	=			fairseq_model.state_dict()
  
  		if not is_headless:
  				lowerCamelCase_  :    str   	=			hf_model.dataavec_audio.feature_extractor
  				lowerCamelCase_  :    List[Any]   	=			hf_model.dataavec_audio.encoder.pos_conv_embed
  
  		else:
  				lowerCamelCase_  :    Dict   	=			hf_model.feature_extractor
  				lowerCamelCase_  :    Union[str, Any]   	=			hf_model.encoder.pos_conv_embed
  
  		for name, value in fairseq_dict.items():
  				lowerCamelCase_  :    int   	=			False
  				if "conv_layers" in name:
  						load_conv_layer(
  						    lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,)
  						lowerCamelCase_  :    int   	=			True
  				elif "pos_conv" in name:
  						load_pos_conv_layer(
  						    lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,)
  						lowerCamelCase_  :    Optional[int]   	=			True
  				else:
  						for key, mapped_key in MAPPING.items():
  								if not is_headless:
  										lowerCamelCase_  :    int   	=			'data2vec_audio.' + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
  								if key in name or key.split('w2v_model.'	)[-1] == name.split('.'	)[0]:
  										lowerCamelCase_  :    int   	=			True
  										if "*" in mapped_key:
  												lowerCamelCase_  :    List[str]   	=			name.split(lowerCAmelCase__	)[0].split('.'	)[-2]
  												lowerCamelCase_  :    Union[str, Any]   	=			mapped_key.replace('*'       ,lowerCAmelCase__	)
  										if "weight_g" in name:
  												lowerCamelCase_  :    Tuple   	=			'weight_g'
  										elif "weight_v" in name:
  												lowerCamelCase_  :    int   	=			'weight_v'
  										elif "bias" in name:
  												lowerCamelCase_  :    List[str]   	=			'bias'
  										elif "weight" in name:
  												# TODO: don't match quantizer.weight_proj
  												lowerCamelCase_  :    Union[str, Any]   	=			'weight'
  										else:
  												lowerCamelCase_  :    List[str]   	=			None
  										set_recursively(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	)
  								continue
  				if not is_used:
  						unused_weights.append(lowerCAmelCase__	)
  
  		logger.warning(F"Unused weights: {unused_weights}"	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__	):
  		lowerCamelCase_  :    Optional[Any]   	=			path.split('.'	)
  		return reduce(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	):
  		lowerCamelCase_  :    Any   	=			access_by_string(lowerCAmelCase__       ,lowerCAmelCase__	)
  		lowerCamelCase_  :    List[str]   	=			hf_weight.data
  
  		if fsq_value.shape != hf_value.shape:
  				raise ValueError(F"{full_name} has size {fsq_value.shape}, but {hf_value.shape} was found."	)
  		lowerCamelCase_  :    str   	=			fsq_value
  		logger.info(F"{full_name} was correctly initialized from {hf_weight_path}."	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	):
  		lowerCamelCase_  :    int   	=			full_name.split('conv_layers.'	)[-1]
  		lowerCamelCase_  :    Optional[int]   	=			name.split('.'	)
  		lowerCamelCase_  :    str   	=			int(items[0]	)
  		lowerCamelCase_  :    str   	=			int(items[1]	)
  
  		lowerCamelCase_  :    Dict   	=			name.split('.'	)[-1]
  		if type_id == 0:
  				lowerCamelCase_  :    Any   	=			'conv'
  		elif type_id == 2:
  				lowerCamelCase_  :    Union[str, Any]   	=			'layer_norm'
  		else:
  				unused_weights.append(lowerCAmelCase__	)
  				return
  
  		set_weights(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,F"conv_layers.{layer_id}.{layer_type}.{weight_type}"	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__	):
  		lowerCamelCase_  :    List[Any]   	=			full_name.split('pos_conv.'	)[-1]
  		lowerCamelCase_  :    Tuple   	=			name.split('.'	)
  		lowerCamelCase_  :    Tuple   	=			int(items[0]	)
  		lowerCamelCase_  :    Dict   	=			int(items[1]	)
  
  		lowerCamelCase_  :    int   	=			name.split('.'	)[-1]
  		if type_id != 0:
  				unused_weights.append(lowerCAmelCase__	)
  				return
  		else:
  				lowerCamelCase_  :    Union[str, Any]   	=			'conv'
  
  		set_weights(lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,F"layers.{layer_id}.{layer_type}.{weight_type}"	)
  
  
  @torch.no_grad()
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__=None       ,lowerCAmelCase__=None       ,lowerCAmelCase__=True	):
  		if config_path is not None:
  				lowerCamelCase_  :    Union[str, Any]   	=			DataaVecAudioConfig.from_pretrained(lowerCAmelCase__	)
  		else:
  				lowerCamelCase_  :    int   	=			DataaVecAudioConfig()
  
  		if not is_finetuned:
  				# Modify final_proj layer name
  				lowerCamelCase_  :    Tuple   	=			DataaVecAudioModel(lowerCAmelCase__	)
  				lowerCamelCase_  :    Optional[Any]   	=			os.path.dirname(lowerCAmelCase__	)
  
  				lowerCamelCase_  :    List[Any]   	=			torch.load(lowerCAmelCase__	)
  				lowerCamelCase_  :    Dict   	=			state_dict['model'].pop('final_proj.0.weight'	)
  				lowerCamelCase_  :    Optional[Any]   	=			state_dict['model'].pop('final_proj.0.bias'	)
  				lowerCamelCase_  :    Union[str, Any]   	=			os.path.join(lowerCAmelCase__       ,'converted.pt'	)
  				torch.save(lowerCAmelCase__       ,lowerCAmelCase__	)
  		else:
  				lowerCamelCase_  :    Optional[Any]   	=			DataaVecAudioForCTC(lowerCAmelCase__	)
  				lowerCamelCase_  :    Optional[Any]   	=			checkpoint_path
  
  		def load_dataavec(lowerCAmelCase__	):
  				lowerCamelCase_	,			lowerCamelCase_	,			lowerCamelCase_  :    Tuple   	=			fairseq.checkpoint_utils.load_model_ensemble_and_task([path]	)
  				return model[0].eval()
  
  		lowerCamelCase_  :    List[str]   	=			load_dataavec(lowerCAmelCase__	)
  
  		recursively_load_weights(lowerCAmelCase__       ,lowerCAmelCase__       ,not is_finetuned	)
  
  		lowerCamelCase_  :    int   	=			WavaVecaProcessor.from_pretrained('facebook/wav2vec2-large-lv60'	)
  
  		lowerCamelCase_  :    Tuple   	=			load_dataset('patrickvonplaten/librispeech_asr_dummy'       ,'clean'       ,split='validation'	)
  		lowerCamelCase_  :    Any   	=			[x['array'] for x in ds[:4]['audio']]
  
  		lowerCamelCase_  :    List[str]   	=			processor(lowerCAmelCase__       ,return_tensors='pt'       ,padding=lowerCAmelCase__	)
  
  		lowerCamelCase_  :    Any   	=			inputs.input_values
  		lowerCamelCase_  :    int   	=			inputs.attention_mask
  		#    input_values = inputs.input_values[:, :-1]
  		#    attention_mask = inputs.attention_mask[:, :-1]
  
  		hf_wavavec.eval()
  		model.eval()
  		if is_finetuned:
  				lowerCamelCase_  :    Dict   	=			model(source=lowerCAmelCase__       ,padding_mask=(1 - attention_mask)       ,mask=lowerCAmelCase__       ,features_only=lowerCAmelCase__	)[
  				    'encoder_out'
  				].transpose(0       ,1	)
  				lowerCamelCase_  :    Any   	=			hf_wavavec(lowerCAmelCase__       ,attention_mask=lowerCAmelCase__	)['logits']
  
  				lowerCamelCase_  :    int   	=			torch.argmax(lowerCAmelCase__       ,dim=-1	)
  				lowerCamelCase_  :    Any   	=			processor.batch_decode(lowerCAmelCase__	)
  
  				print(F"Expected Output: {ds[:4]['text']}, Pred: {output_string}"	)
  		else:
  				lowerCamelCase_  :    str   	=			model(source=lowerCAmelCase__       ,padding_mask=(1 - attention_mask)       ,mask=lowerCAmelCase__       ,features_only=lowerCAmelCase__	)[
  				    'layer_results'
  				][-1][0].transpose(0       ,1	)
  				lowerCamelCase_  :    str   	=			hf_wavavec(lowerCAmelCase__       ,attention_mask=lowerCAmelCase__	)['last_hidden_state']
  
  		print(our_output.shape       ,their_output.shape	)
  		lowerCamelCase_  :    List[str]   	=			torch.max(torch.abs(our_output - their_output	)	).item()
  		print(F"max_absolute_diff = {max_absolute_diff}"	)  # ~ 1e-7
  		lowerCamelCase_  :    Optional[Any]   	=			torch.allclose(lowerCAmelCase__       ,lowerCAmelCase__       ,atol=1e-3	)
  		print('Do both models output the same tensors?'       ,'🔥' if success else '💩'	)
  		if not success:
  				raise Exception('Something went wRoNg'	)
  
  		hf_wavavec.save_pretrained(lowerCAmelCase__	)
  
  		if is_finetuned:
  				processor.save_pretrained(lowerCAmelCase__	)
  		else:
  				processor.feature_extractor.save_pretrained(lowerCAmelCase__	)
  
  
  if __name__ == "__main__":
  		_lowercase		:     Union[str, Any] 					=argparse.ArgumentParser()
  		parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
  		parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
  		parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""")
  		parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
  		parser.add_argument(
  		    """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not"""
  		)
  		_lowercase		:     Dict 					=parser.parse_args()
  		convert_wavaveca_checkpoint(
  		    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
  		)
  
style_context: 
  
  
  
  
  
  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()
  
  
  _lowercase		:     Optional[Any] 					="""./tests/fixtures/elise_format0.mid"""
  
  
  
  
  
  
  @unittest.skip('The note-seq package currently throws an error on import'       )
  class 	UpperCamelCase_     (     snake_case__     ,    unittest.TestCase       ):
  					_a			:	int							=				SpectrogramDiffusionPipeline
  					_a			:	Dict							=				PipelineTesterMixin.required_optional_params - {
  					    'callback',
  					    'latents',
  					    'callback_steps',
  					    'output_type',
  					    'num_images_per_prompt',
  					}
  					_a			:	str							=				False
  					_a			:	Union[str, Any]							=				False
  					_a			:	Optional[int]							=				TOKENS_TO_AUDIO_GENERATION_PARAMS
  					_a			:	Optional[Any]							=				TOKENS_TO_AUDIO_GENERATION_BATCH_PARAMS
  
  
  
  					def      __a    (		self    :    Dict	):
  							torch.manual_seed(0	)
  							lowerCamelCase_  :    List[str]   	=			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'					,			)
  
  							lowerCamelCase_  :    Union[str, Any]   	=			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'					,			)
  
  							lowerCamelCase_  :    Union[str, Any]   	=			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					,			)
  
  							lowerCamelCase_  :    Any   	=			DDPMScheduler()
  
  							lowerCamelCase_  :    str   	=			{
  							    'notes_encoder': notes_encoder.eval(),
  							    'continuous_encoder': continuous_encoder.eval(),
  							    'decoder': decoder.eval(),
  							    'scheduler': scheduler,
  							    'melgan': None,
  							}
  							return components
  
  
  
  					def      __a    (		self    :    Any					,			lowerCamelCase    :    Any					,			lowerCamelCase    :    int=0	):
  							if str(lowerCamelCase	).startswith('mps'	):
  									lowerCamelCase_  :    Optional[int]   	=			torch.manual_seed(lowerCamelCase	)
  							else:
  									lowerCamelCase_  :    Dict   	=			torch.Generator(device=lowerCamelCase	).manual_seed(lowerCamelCase	)
  							lowerCamelCase_  :    str   	=			{
  							    '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    :    Dict	):
  							lowerCamelCase_  :    str   	=			'cpu'  # ensure determinism for the device-dependent torch.Generator
  							lowerCamelCase_  :    Dict   	=			self.get_dummy_components()
  							lowerCamelCase_  :    Tuple   	=			SpectrogramDiffusionPipeline(**lowerCamelCase	)
  							lowerCamelCase_  :    List[str]   	=			pipe.to(lowerCamelCase	)
  							pipe.set_progress_bar_config(disable=lowerCamelCase	)
  
  							lowerCamelCase_  :    Optional[Any]   	=			self.get_dummy_inputs(lowerCamelCase	)
  							lowerCamelCase_  :    str   	=			pipe(**lowerCamelCase	)
  							lowerCamelCase_  :    Tuple   	=			output.audios
  
  							lowerCamelCase_  :    Tuple   	=			mel[0, -3:, -3:]
  
  							assert mel_slice.shape == (3, 3)
  							lowerCamelCase_  :    List[str]   	=			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    :    Any	):
  							return super().test_save_load_local()
  
  
  
  					@skip_mps
  					def      __a    (		self    :    Tuple	):
  							return super().test_dict_tuple_outputs_equivalent()
  
  
  
  					@skip_mps
  					def      __a    (		self    :    Dict	):
  							return super().test_save_load_optional_components()
  
  
  
  					@skip_mps
  					def      __a    (		self    :    str	):
  							return super().test_attention_slicing_forward_pass()
  
  
  
  					def      __a    (		self    :    Any	):
  							pass
  
  
  
  					def      __a    (		self    :    Optional[int]	):
  							pass
  
  
  
  
  
  					@skip_mps
  					def      __a    (		self    :    Optional[Any]	):
  							return super().test_progress_bar()
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  @require_onnxruntime
  @require_note_seq
  class 	UpperCamelCase_     (     unittest.TestCase       ):
  
  
  
  					def      __a    (		self    :    Optional[int]	):
  							# clean up the VRAM after each test
  							super().tearDown()
  							gc.collect()
  							torch.cuda.empty_cache()
  
  
  
  					def      __a    (		self    :    str	):
  							# TODO - test that pipeline can decode tokens in a callback
  							# so that music can be played live
  							lowerCamelCase_  :    Optional[Any]   	=			torch_device
  
  							lowerCamelCase_  :    Union[str, Any]   	=			SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion'	)
  							lowerCamelCase_  :    str   	=			pipe.melgan
  							lowerCamelCase_  :    Optional[int]   	=			None
  
  							lowerCamelCase_  :    str   	=			pipe.to(lowerCamelCase	)
  							pipe.set_progress_bar_config(disable=lowerCamelCase	)
  
  							def callback(lowerCamelCase    :    int					,			lowerCamelCase    :    int	):
  									# decode mel to audio
  									lowerCamelCase_  :    Union[str, Any]   	=			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
  
  							lowerCamelCase_  :    Any   	=			MidiProcessor()
  							lowerCamelCase_  :    str   	=			processor(lowerCamelCase	)
  
  							lowerCamelCase_  :    str   	=			input_tokens[:3]
  							lowerCamelCase_  :    Dict   	=			torch.manual_seed(0	)
  							pipe(lowerCamelCase					,			num_inference_steps=5					,			generator=lowerCamelCase					,			callback=lowerCamelCase					,			output_type='mel'	)
  
  
  
  					def      __a    (		self    :    str	):
  							lowerCamelCase_  :    List[str]   	=			torch_device
  
  							lowerCamelCase_  :    List[str]   	=			SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion'	)
  							lowerCamelCase_  :    Union[str, Any]   	=			pipe.to(lowerCamelCase	)
  							pipe.set_progress_bar_config(disable=lowerCamelCase	)
  							lowerCamelCase_  :    int   	=			MidiProcessor()
  
  							lowerCamelCase_  :    Dict   	=			processor(lowerCamelCase	)
  							# just run two denoising loops
  							lowerCamelCase_  :    Optional[Any]   	=			input_tokens[:2]
  
  							lowerCamelCase_  :    List[Any]   	=			torch.manual_seed(0	)
  							lowerCamelCase_  :    str   	=			pipe(lowerCamelCase					,			num_inference_steps=2					,			generator=lowerCamelCase	)
  
  							lowerCamelCase_  :    Dict   	=			output.audios[0]
  
  							assert abs(np.abs(lowerCamelCase	).sum() - 3_612.841	) < 1E-1
  
  
  
  
  
  					def      __a    (		self    :    List[Any]	):
  							lowerCamelCase_  :    int   	=			torch_device
  
  							lowerCamelCase_  :    str   	=			SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion'	)
  							lowerCamelCase_  :    Optional[int]   	=			pipe.to(lowerCamelCase	)
  							pipe.set_progress_bar_config(disable=lowerCamelCase	)
  
  							lowerCamelCase_  :    Tuple   	=			MidiProcessor()
  
  							lowerCamelCase_  :    int   	=			processor(lowerCamelCase	)
  
  							# just run 4 denoising loops
  							lowerCamelCase_  :    Optional[Any]   	=			input_tokens[:4]
  
  							lowerCamelCase_  :    List[Any]   	=			torch.manual_seed(0	)
  							lowerCamelCase_  :    int   	=			pipe(lowerCamelCase					,			num_inference_steps=1_00					,			generator=lowerCamelCase	)
  
  							lowerCamelCase_  :    List[Any]   	=			output.audios[0]
  							assert abs(np.abs(lowerCamelCase	).sum() - 9_389.1_111	) < 5E-2
  