


import argparse
import os

import jax as jnp
import numpy as onp
import torch
import torch.nn as nn
from music_spectrogram_diffusion import inference
from tax import checkpoints

from diffusers import DDPMScheduler, OnnxRuntimeModel, SpectrogramDiffusionPipeline
from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder


A      = "base_with_context"





def __UpperCAmelCase       (		__A ,						__A			)						->					List[Any]:



       '''simple docstring'''





       UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(weights["token_embedder"]["embedding"]			)			)
       UpperCAmelCase__										=     nn.Parameter(
           torch.FloatTensor(weights["Embed_0"]["embedding"]			) ,						requires_grad=__A			)
       for lyr_num, lyr in enumerate(model.encoders			):
              UpperCAmelCase__										=     weights[F"""layers_{lyr_num}"""]
              UpperCAmelCase__										=     nn.Parameter(
                  torch.FloatTensor(ly_weight["pre_attention_layer_norm"]["scale"]			)			)

              UpperCAmelCase__										=     ly_weight["attention"]
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["query"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["key"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["value"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["out"]["kernel"].T			)			)

              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["pre_mlp_layer_norm"]["scale"]			)			)

              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_0"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_1"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wo"]["kernel"].T			)			)

       UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(weights["encoder_norm"]["scale"]			)			)
       return model





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



       '''simple docstring'''





       UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(weights["input_proj"]["kernel"].T			)			)

       UpperCAmelCase__										=     nn.Parameter(
           torch.FloatTensor(weights["Embed_0"]["embedding"]			) ,						requires_grad=__A			)

       for lyr_num, lyr in enumerate(model.encoders			):
              UpperCAmelCase__										=     weights[F"""layers_{lyr_num}"""]
              UpperCAmelCase__										=     ly_weight["attention"]

              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["query"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["key"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["value"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["out"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(
                  torch.FloatTensor(ly_weight["pre_attention_layer_norm"]["scale"]			)			)

              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_0"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_1"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wo"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["pre_mlp_layer_norm"]["scale"]			)			)

       UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(weights["encoder_norm"]["scale"]			)			)

       return model





def __UpperCAmelCase       (		__A ,						__A			)						->					str:



       '''simple docstring'''





       UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(weights["time_emb_dense0"]["kernel"].T			)			)
       UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(weights["time_emb_dense1"]["kernel"].T			)			)

       UpperCAmelCase__										=     nn.Parameter(
           torch.FloatTensor(weights["Embed_0"]["embedding"]			) ,						requires_grad=__A			)

       UpperCAmelCase__										=     nn.Parameter(
           torch.FloatTensor(weights["continuous_inputs_projection"]["kernel"].T			)			)

       for lyr_num, lyr in enumerate(model.decoders			):
              UpperCAmelCase__										=     weights[F"""layers_{lyr_num}"""]
              UpperCAmelCase__										=     nn.Parameter(
                  torch.FloatTensor(ly_weight["pre_self_attention_layer_norm"]["scale"]			)			)

              UpperCAmelCase__										=     nn.Parameter(
                  torch.FloatTensor(ly_weight["FiLMLayer_0"]["DenseGeneral_0"]["kernel"].T			)			)

              UpperCAmelCase__										=     ly_weight["self_attention"]
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["query"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["key"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["value"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["out"]["kernel"].T			)			)

              UpperCAmelCase__										=     ly_weight["MultiHeadDotProductAttention_0"]
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["query"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["key"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["value"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(attention_weights["out"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(
                  torch.FloatTensor(ly_weight["pre_cross_attention_layer_norm"]["scale"]			)			)

              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["pre_mlp_layer_norm"]["scale"]			)			)
              UpperCAmelCase__										=     nn.Parameter(
                  torch.FloatTensor(ly_weight["FiLMLayer_1"]["DenseGeneral_0"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_0"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wi_1"]["kernel"].T			)			)
              UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(ly_weight["mlp"]["wo"]["kernel"].T			)			)

       UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(weights["decoder_norm"]["scale"]			)			)

       UpperCAmelCase__										=     nn.Parameter(torch.FloatTensor(weights["spec_out_dense"]["kernel"].T			)			)

       return model





def __UpperCAmelCase       (		__A			)						->					Optional[Any]:



       '''simple docstring'''





       UpperCAmelCase__										=     checkpoints.load_tax_checkpoint(args.checkpoint_path			)
       UpperCAmelCase__										=     jnp.tree_util.tree_map(onp.array ,						__A			)

       UpperCAmelCase__										=     [
           "from __gin__ import dynamic_registration",
           "from music_spectrogram_diffusion.models.diffusion import diffusion_utils",
           "diffusion_utils.ClassifierFreeGuidanceConfig.eval_condition_weight = 2.0",
           "diffusion_utils.DiffusionConfig.classifier_free_guidance = @diffusion_utils.ClassifierFreeGuidanceConfig()",
       ]

       UpperCAmelCase__										=     os.path.join(args.checkpoint_path ,						".." ,						"config.gin"			)
       UpperCAmelCase__										=     inference.parse_training_gin_file(__A ,						__A			)
       UpperCAmelCase__										=     inference.InferenceModel(args.checkpoint_path ,						__A			)

       UpperCAmelCase__										=     DDPMScheduler(beta_schedule="squaredcos_cap_v2" ,						variance_type="fixed_large"			)

       UpperCAmelCase__										=     SpectrogramNotesEncoder(
           max_length=synth_model.sequence_length["inputs"] ,						vocab_size=synth_model.model.module.config.vocab_size ,						d_model=synth_model.model.module.config.emb_dim ,						dropout_rate=synth_model.model.module.config.dropout_rate ,						num_layers=synth_model.model.module.config.num_encoder_layers ,						num_heads=synth_model.model.module.config.num_heads ,						d_kv=synth_model.model.module.config.head_dim ,						d_ff=synth_model.model.module.config.mlp_dim ,						feed_forward_proj="gated-gelu" ,						)

       UpperCAmelCase__										=     SpectrogramContEncoder(
           input_dims=synth_model.audio_codec.n_dims ,						targets_context_length=synth_model.sequence_length["targets_context"] ,						d_model=synth_model.model.module.config.emb_dim ,						dropout_rate=synth_model.model.module.config.dropout_rate ,						num_layers=synth_model.model.module.config.num_encoder_layers ,						num_heads=synth_model.model.module.config.num_heads ,						d_kv=synth_model.model.module.config.head_dim ,						d_ff=synth_model.model.module.config.mlp_dim ,						feed_forward_proj="gated-gelu" ,						)

       UpperCAmelCase__										=     TaFilmDecoder(
           input_dims=synth_model.audio_codec.n_dims ,						targets_length=synth_model.sequence_length["targets_context"] ,						max_decoder_noise_time=synth_model.model.module.config.max_decoder_noise_time ,						d_model=synth_model.model.module.config.emb_dim ,						num_layers=synth_model.model.module.config.num_decoder_layers ,						num_heads=synth_model.model.module.config.num_heads ,						d_kv=synth_model.model.module.config.head_dim ,						d_ff=synth_model.model.module.config.mlp_dim ,						dropout_rate=synth_model.model.module.config.dropout_rate ,						)

       UpperCAmelCase__										=     load_notes_encoder(ta_checkpoint["target"]["token_encoder"] ,						__A			)
       UpperCAmelCase__										=     load_continuous_encoder(ta_checkpoint["target"]["continuous_encoder"] ,						__A			)
       UpperCAmelCase__										=     load_decoder(ta_checkpoint["target"]["decoder"] ,						__A			)

       UpperCAmelCase__										=     OnnxRuntimeModel.from_pretrained("kashif/soundstream_mel_decoder"			)

       UpperCAmelCase__										=     SpectrogramDiffusionPipeline(
           notes_encoder=__A ,						continuous_encoder=__A ,						decoder=__A ,						scheduler=__A ,						melgan=__A ,						)
       if args.save:
              pipe.save_pretrained(args.output_path			)


if __name__ == "__main__":
    A      = argparse.ArgumentParser()

    parser.add_argument("--output_path", default=None, type=str, required=True, help="Path to the converted model.")
    parser.add_argument(
        "--save", default=True, type=bool, required=False, help="Whether to save the converted model or not."
    )
    parser.add_argument(
        "--checkpoint_path",
        default=f"{MODEL}/checkpoint_500000",
        type=str,
        required=False,
        help="Path to the original jax model checkpoint.",
    )
    A      = parser.parse_args()

    main(args)









from __future__ import annotations





def __UpperCAmelCase       (		__A ,						__A ,						__A ,						)						->					tuple:



       '''simple docstring'''





       if (electron_conc, hole_conc, intrinsic_conc).count(0			) != 1:
              raise ValueError("You cannot supply more or less than 2 values"			)
       elif electron_conc < 0:
              raise ValueError("Electron concentration cannot be negative in a semiconductor"			)
       elif hole_conc < 0:
              raise ValueError("Hole concentration cannot be negative in a semiconductor"			)
       elif intrinsic_conc < 0:
              raise ValueError(
                  "Intrinsic concentration cannot be negative in a semiconductor"			)
       elif electron_conc == 0:
              return (
                  "electron_conc",
                  intrinsic_conc**2 / hole_conc,
              )
       elif hole_conc == 0:
              return (
                  "hole_conc",
                  intrinsic_conc**2 / electron_conc,
              )
       elif intrinsic_conc == 0:
              return (
                  "intrinsic_conc",
                  (electron_conc * hole_conc) ** 0.5,
              )
       else:
              return (-1, -1)


if __name__ == "__main__":
    import doctest

    doctest.testmod()





